Samacheer Kalvi Class 12 Computer Applications Solutions Chapter 9 Connecting PHP and MYSQL

Part I

Choose The Correct Answers

 

Question 1. Which one of the following statements instantiates the mysqli class?
(a) mysqli = new mysqli()
(b) $mysqli = new mysqli()
(c) $mysqfl->new.mysqli()
(d) mysqli->new.mysqli()
Answer: (b) $mysqli = new mysqli()
In simple words: To create a new object of the mysqli class, you need to use the dollar sign ($) before the variable name "mysqli". This helps to properly start a new connection to the database.

🎯 Exam Tip: Remember that in PHP, variable names always begin with a dollar sign ($).

 

Question 2. Which one is correct way, we can retrieve the data in the result set of MySQL using PHP?
(a) mysql_fetch_row
(b) mysql_fetch_array
(c) mysql_fetch_object
(d) All of the options
Answer: (d) All of the options
In simple words: You can get data from a MySQL result set in different ways. Functions like `mysql_fetch_row`, `mysql_fetch_array`, and `mysql_fetch_object` are all valid methods to retrieve information. Each method gives the data in a slightly different format, such as a simple list, an array, or an object.

🎯 Exam Tip: Understand the difference between `mysql_fetch_row` (numeric array), `mysql_fetch_array` (associative and/or numeric array), and `mysql_fetch_object` (object) for different data handling needs.

 

Question 3. How Can we Create a Database Using PHP and MySQL?
(a) mysqli_create_db("Database Name")
(b) mysqli_create_db(" Data")
(c) create_db("Database Name")
(d) create_db("Data")
Answer: (a) mysqli_create_db("Database Name")
In simple words: To make a new database using PHP and MySQL, you use the `mysqli_create_db()` function. You just need to put the name you want for your database inside the parentheses. This function sends a command to MySQL to set up the new database.

🎯 Exam Tip: Always use clear, descriptive names for your databases inside the function to avoid confusion.

 

Question 4. Which is the correct function to execute the SQL queries in PHP ?
(a) mysqli_query("Connection Object'/'SQL Query")
(b) query("Connection Object","SQL Query")
(c) mysql_query("Connection Object”,”SQL Query")
(d) mysql_query("SQL Query")
Answer: (a) mysqli_query("Connection Object'/'SQL Query")
In simple words: To run SQL commands in PHP, you use the `mysqli_query()` function. This function needs two main things: the connection object that links to your database, and the actual SQL command you want to run. It helps PHP talk to the database to perform actions like getting or changing data.

🎯 Exam Tip: Always ensure your SQL query is correctly structured and safe from SQL injection attacks when using `mysqli_query()`.

 

Question 5. Which is the correct function Closing Connection in PHP ?
(a) mysqli_close("Connection Object");
(b) close("Connection Object”);
(c) mysql_close("Connection Object”);
(d) mysqli_close(“Database Object");
Answer: (c) mysql_close("Connection Object”);
In simple words: After you are done using a database connection in PHP, it's good practice to close it. The `mysql_close()` function is used for this. You pass the connection object to it, and it will end the link between your PHP script and the MySQL database, freeing up resources.

🎯 Exam Tip: Closing database connections is important to release server resources, especially in high-traffic applications.

 

Question 6. Which is the correct function to establish Connection in PHP ?
(a) mysqli_connect(“Server Name “,” ‘User Name “,”- Password “,” DB Name”);
(b) connect("'Server Name “,” User Name”,”Pass-word","DB Name");
(c) mysql_connect(“Server Name “,” User Name “,” Password ",” DB Name”);
(d) mysqli_connect ("Database Object'"');
Answer: (c) mysql_connect(“Server Name “,” User Name “,” Password “,” DB Name”);
In simple words: To start a connection to a MySQL database from PHP, you use the `mysql_connect()` function. This function needs details like the server address, your username, password, and the database name to properly link your script to the database. Making a connection is the first step before you can run any queries.

🎯 Exam Tip: Ensure the server name, username, password, and database name are all correct and securely managed to establish a successful connection.

 

Question 7. Which is the not a correct MySQL Function in PHP ?
(a) Mysqli_connect() Function
(b) Mysqli_close() Function
(c) mysqli_select_data() Function
(d) mysqli_affected_rows() Function
Answer: (c) mysqli_select_data() Function
In simple words: Among the options, `mysqli_select_data()` is not a standard or correct function for MySQL operations in PHP. Functions like `mysqli_connect()`, `mysqli_close()`, and `mysqli_affected_rows()` are valid for connecting, closing, and checking the number of rows changed, respectively. The name `mysqli_select_data()` doesn't match any official PHP MySQLi function.

🎯 Exam Tip: Familiarize yourself with the common and correct `mysqli_` functions to avoid using non-existent ones.

 

Question 8. How many parameter are required for MYSQLi connect function in PHP ?
(a) 2
(b) 3
(c) 4
(d) 5
Answer: (c) 4
In simple words: The `mysqli_connect()` function typically needs four pieces of information to connect to a MySQL database. These are the server name, username, password, and the name of the database you want to connect to. Sometimes, you can skip the database name if you select it later, but generally, four parameters are expected for a full connection.

🎯 Exam Tip: The four standard parameters for `mysqli_connect()` are hostname, username, password, and database name. Provide them in the correct order.

 

Question 9. How many parameter are required for MYSQLI query function in PHP ?
(a) 2
(b) 3
(c) 4
(d) 5
Answer: (a) 2
In simple words: The `mysqli_query()` function needs two main pieces of information to work correctly. First, it needs the connection object, which is the link to your database. Second, it needs the actual SQL query string that you want to run. These two parameters tell PHP which database to use and what operation to perform.

🎯 Exam Tip: The two parameters for `mysqli_query()` are the database connection resource and the SQL query string.

 

Question 10. How many parameter are required for MYSQLI Close function in PHP ?
(a) 1
(b) 2
(c) 3
(d) 5
Answer: (a) 1
In simple words: To close a database connection using the `mysqli_close()` function, you only need to provide one piece of information: the connection object itself. This object represents the active link to your database that you want to end. It's a simple way to properly shut down the connection.

🎯 Exam Tip: Always pass the exact connection object variable to `mysqli_close()` to ensure the correct connection is terminated.

 

Question 11. Which version of PHP supports MySQLi fuctions?
(a) Version 2.0
(b) Version 3.0
(c) Version 4.0
(d) Version 5.0
Answer: (d) Version 5.0
In simple words: The MySQLi extension, which offers an improved way to interact with MySQL databases, was first introduced with PHP version 5.0.0. This means that if you are using PHP 5.0 or a newer version, you can take advantage of the MySQLi functions for database operations.

🎯 Exam Tip: Always use MySQLi or PDO for new projects as the older `mysql_` functions are deprecated and less secure.

Part II

Short Answers

 

Question 1. What are the MySQLi function available PHP?
Answer: Some of the important MySQLi functions available in PHP are:
1. `mysqli_connect()` Function: Used to establish a connection to a MySQL database.
2. `mysqli_close()` Function: Used to close an existing database connection.
3. `mysqli_select_db()` Function: Used to select a default database to be used for queries.
4. `mysqli_affected_rows()` Function: Returns the number of affected rows by the previous MySQL operation.
5. `mysqli_connect_error()` Function: Returns the error description from the last connection error.
6. `mysqli_fetch_assoc()` Function: Fetches a result row as an associative array. These functions provide robust ways to interact with MySQL databases securely.
In simple words: PHP has special tools called MySQLi functions to work with MySQL databases. These tools help you do things like connect to the database, close the connection, choose which database to use, see how many rows were changed, find out if there was an error, and get data back in a helpful format.

🎯 Exam Tip: Remember these core functions as they cover the main stages of database interaction: connection, selection, execution, and error handling.

 

Question 2. What is the MySQLi function?
Answer:
* MySQLi is a special tool or "extension" in the PHP scripting language. Its main job is to help PHP programs talk to and manage MySQL databases. It acts as a bridge, allowing your PHP code to send commands to the database and get information back.
* The MySQLi extension first came out with PHP version 5.0.0. It offers improved features and better security compared to older methods of connecting to MySQL.
In simple words: MySQLi is like an advanced helper in PHP that lets your website or program connect to and control MySQL databases. It was added in PHP 5.0.0 for better and safer database work.

🎯 Exam Tip: Emphasize that MySQLi is an "extension" and provides "access to MySQL database," introduced in "PHP 5.0.0."

 

Question 3. What are the types MySQLi function available PHP?
Answer: The types of MySQLi functions available in PHP help manage different aspects of working with a database. They can be grouped into the following categories:
1. **Database connections:** These functions are used to set up and end the link between PHP and the MySQL database.
2. **Managing Database connections:** This includes functions that handle the active connection, like checking its status or selecting a specific database.
3. **Performing Queries:** These functions are for sending SQL commands to the database to fetch, add, update, or delete data.
4. **Closing connection:** A specific set of functions ensures that the database connection is properly shut down when no longer needed.
In simple words: MySQLi functions in PHP can be put into groups based on what they do. Some help you connect to the database, others help manage that connection, some let you ask the database for information, and a final group helps you close the connection when you're done.

🎯 Exam Tip: Categorizing the functions helps to understand their purpose and flow in a typical database interaction: Connect -> Query -> Close.

 

Question 4. Difference between the Connection and Close function?
Answer: The `Connection` and `Close` functions serve opposite but equally important roles in database interaction. Here's how they differ:

A connection function initiates communication, while a close function terminates it, releasing system resources.
In simple words: A 'Connection function' is like opening a door to talk to the database, needing details like where the door is and who you are. A 'Close function' is like shutting that door when you're finished talking, only needing to know which door to close.

🎯 Exam Tip: Clearly state the primary purpose of each function (connect vs. disconnect) and the number of parameters required for a full-mark answer.

 

Question 5. Give few examples of MySQLi Queries.
Answer: Here are a few examples of MySQLi queries used to interact with a database:
* `mysqli_query($con, "SELECT FROM Persons");` - This query fetches all records from a table named "Persons". It's a simple way to retrieve data.
* `mysqli_query($con, 'INSERT INTO Persons (FirstName, LastName, Age) VALUES ("OGlenn","Quagmire",33)');` - This query adds a new record to the "Persons" table with specific first name, last name, and age values. This allows you to add new data.
In simple words: MySQLi queries are commands you send to the database. For example, you can use `SELECT` to get information from a table, or `INSERT` to add new information into a table. You tell the database what to do, and it follows the instructions.

🎯 Exam Tip: When providing examples, always include both a `SELECT` (data retrieval) and an `INSERT` (data modification) query to show versatility.

 

Question 6. What is the connection string?
Answer: A connection string is a set of variables that hold all the necessary information to connect to a database server. These variables are:
1. `$servername` \(\rightarrow\) Database Server IP address (or hostname)
2. `$username` \(\rightarrow\) Database Server User Name
3. `$password` \(\rightarrow\) Database Server Password
4. `$DB_Name` \(\rightarrow\) Database Name
The `mysqli_connect()` function uses these variables to establish a connection between the PHP script and the database server. If the connection fails, an error message with a MySQL error code will be displayed. If successful, the connection is ready to be used.
In simple words: A connection string is like a secret code made of small pieces of information, such as the server address, username, password, and database name. These pieces help PHP know how to reach and log in to the database. If any part of the code is wrong, the connection will fail.

🎯 Exam Tip: List the four essential components of a connection string and explain their role in `mysqli_connect()` for a complete answer.

 

Question 7. What is a web Database?
Answer:
* A web database is a special type of database application that is designed to be managed and accessed primarily through the Internet. This means users interact with it using a web browser or web application, rather than a desktop program.
* In simpler terms, these are the smaller, lighter databases that support web applications. They store information for websites, allowing dynamic content, user accounts, and other interactive features to function smoothly online.
In simple words: A web database is a database that people can use and manage through the internet, often with a website. It helps websites store and show changing information.

🎯 Exam Tip: Highlight "managed and accessed through the Internet" and its role in "supporting web applications" when defining a web database.

 

Question 8. What is mysqli_fetch_assoc() Function?
Answer: The `mysqli_fetch_assoc()` function is used to get one row of data from a query result set. It brings back the data as an associative array, where the keys of the array match the names of the columns in your database table. This makes it easy to access data using column names.
**Syntax:**
`mysqli_fetch_assoc(result);`
In simple words: The `mysqli_fetch_assoc()` function takes one row of data from your database results. It turns that row into a special list where you can find each piece of data by its column name.

🎯 Exam Tip: Explain that it fetches a row as an "associative array" and mention that array keys correspond to "column names."

 

Question 9. Define mysqli_connect_error() Function.
Answer: The `mysqli_connect_error()` function is a very helpful tool in PHP for debugging database connection issues. It returns a string that describes the error that occurred during the last attempt to connect to a MySQL database. If no error happened, it will return an empty string. This function helps developers understand why a connection failed.
**Syntax:**
`mysqli_connect_error();`
In simple words: The `mysqli_connect_error()` function tells you if something went wrong when trying to connect to a database. If there was an error, it gives you a message explaining what happened, which is useful for fixing problems.

🎯 Exam Tip: Emphasize its role in "error description" for "last connection error" to show its specific diagnostic purpose.

 

Question 10. Define mysqli_affected_rows() Function.
Answer: The `mysqli_affected_rows()` function is used to find out how many rows were changed, inserted, or deleted by the most recent MySQL operation. For example, after an `UPDATE` or `DELETE` query, this function will tell you exactly how many records in the database were impacted. It returns the number of affected rows.
**Syntax:**
`mysqli_affected_rows(connection)`
In simple words: The `mysqli_affected_rows()` function counts how many rows in the database were changed by your last command, like when you added, updated, or removed data. It helps you see how much your command actually did.

🎯 Exam Tip: Stress that it returns the count of rows "affected" by the "previous MySQL operation," specifically for `INSERT`, `UPDATE`, or `DELETE` queries.

Part III

Explain In Brief Answers

 

Question 1. Write the Syntax for MySQLi Queries.
Answer: The `mysqli_query()` function is used to execute SQL queries against a MySQL database. Its general syntax, along with its parameters, is as follows:
**Syntax:**
`mysqli_query("Connection Object”, ”SQL Query”)`

The `resultmode` parameter gives you control over how query results are managed, especially for large datasets. This flexibility helps with performance.
In simple words: To run a command on a MySQL database, you use `mysqli_query()`. You need to tell it which database connection to use and what SQL command you want to run. There's also an optional setting to choose how the results are handled, especially for big lists of data.

🎯 Exam Tip: Clearly list the required parameters (connection, query) and explain the optional `resultmode` with its two main constants for a comprehensive answer.

 

Question 2. Write is the purpose of MySQLi function available.
Answer: The main purpose of the MySQLi functions available in PHP is to provide a robust and secure way for PHP scripts to interact with MySQL databases. These functions serve several key objectives:
* MySQLi is an extension in the PHP scripting language that offers access to the MySQL database. It helps PHP communicate with MySQL.
* The MySQLi functions are specially designed to communicate effectively with MySQL, ensuring smooth data exchange.
* The `mysqli_query()` function, a core part of MySQLi, performs queries against the database. This means it sends commands to get, add, update, or remove data.
Overall, MySQLi makes it possible for web applications to store, retrieve, and manage data dynamically, which is essential for most modern websites.
In simple words: MySQLi functions in PHP are used to let PHP programs talk to MySQL databases. They help in connecting, sending commands, and getting data from the database. This allows websites to store and use information.

🎯 Exam Tip: Focus on "access to MySQL database," "designed to communicate," and "performs queries" as the core purposes of MySQLi functions.

 

Question 3. Differentiate mysq I i_jaffected_rows() Function and mysqli_fetch_assoc() Function.
Answer: The `mysqli_affected_rows()` and `mysqli_fetch_assoc()` functions serve distinct purposes when interacting with a MySQL database in PHP:

In summary, one function tells you "how many changes" were made, while the other helps you "get the data" from a result set. They are both vital for database management but in different ways.
In simple words: `mysqli_affected_rows()` tells you how many records were changed by your last command (like adding or deleting). `mysqli_fetch_assoc()` helps you read one row of data from the database, giving you column names to find information easily.

🎯 Exam Tip: Clearly state the primary output of each function (number of affected rows vs. an associative array row) and their respective inputs (connection vs. result set).

 

Question 4. Write MySQL Connection Syntax with example.
Answer: To connect to a MySQL database using PHP, you typically use the `mysqli_connect()` function. This function requires several parameters to establish a successful connection.
**Syntax:**
`mysqli_connect("Server Name”, “User Name”, “password”, “DB Name”);`
**Example:**
Let's imagine you want to connect to a local database called "SchoolDB" with a standard username and password. Here's how you would write the connection code:
``$servername = "localhost";`
`$username = "username";`
`$password = "password";`
`$DB_name = "SchooLDB";`
`// Create connection`
`$conn = mysqli_connect($servername, $username, $password, $DB_name);`
`?>`
This example creates a connection object named `$conn` that can then be used for all further database operations. If the connection fails, an error message would be generated, which is important for debugging.
In simple words: To link your PHP program to a MySQL database, you use `mysqli_connect()`. You need to give it the server's address, your username, your password, and the database's name. For example, you can set these details as variables and then pass them to the `mysqli_connect()` function to make the connection.

🎯 Exam Tip: Provide the general syntax first, then a complete, working PHP code example with common placeholder values for the connection parameters.

 

Question 5. Write a note PHP MySQL database connection.
Answer: Connecting a PHP script to a MySQL database is a fundamental step for building dynamic web applications. The combination of PHP and MySQL has become a very popular server-side web scripting solution because of its ease of use and powerful capabilities.
* PHP, combined with MySQL, forms a powerful duo for server-side web scripting on the internet. This setup allows websites to interact with databases to store and retrieve information.
* The connectivity between MySQL and PHP scripting language covers various essential steps. These include establishing the database connection itself, selecting a specific database, executing SQL statements (like adding, updating, or querying data), and finally, properly terminating the connection to free up resources. This complete cycle ensures efficient data management.
In simple words: PHP and MySQL work well together to make websites that can save and get information. Connecting them means starting a link, picking the right database, telling it what to do, and then closing the link.

🎯 Exam Tip: Emphasize the "popular combination" aspect and list the key stages of database connectivity (establishment, selection, execution, termination).

Part IV

Explain In Detail

 

Question 1. Discuss in detail MySQL functions for example.
Answer: In PHP scripting language, many powerful functions are available to interact with MySQL databases, enabling smooth connectivity and the execution of various SQL queries. The MySQLi extension is particularly important as it provides an improved way to access MySQL databases, having been introduced in PHP version 5.0.0. Here are some of the key MySQL functions with examples:
* MySQLi is an extension in PHP scripting language which provides access to the MySQL database. It acts as a bridge for PHP to communicate with MySQL.
* MySQLi extension was introduced in PHP version 5.0.0, bringing enhanced features and security.
* Some important MySQL functions include:
* **MySQL COUNT Function:** This aggregate function is used to count the number of rows in a database table. It helps in knowing the total entries.
* Example: `mysql> SELECT COUNT(*) FROM employee_tbl;`
* **MySQL MAX Function:** This aggregate function allows you to select the highest (maximum) value for a certain column. It is useful for finding the largest value in a set of data.
* Example: `mysql > SELECT MAX(daily_typing_pages) FROM employee_tbl;`
* **MySQL MIN Function:** The MySQL MIN aggregate function selects the lowest (minimum) value for a certain column. This helps in finding the smallest value in a data set.
* Example: `MySQL > SELECT MIN(daily_typing_pages) FROM employee_tbl;`
* **MySQL AVG Function:** The MySQL AVG aggregate function selects the average value for a certain table column. This provides the mean value of a numeric column.
* Example: `MySQL > SELECT AVG(daily_typing_pages) FROM employee_tbl;`
* **MySQL SUM Function:** The MySQL SUM aggregate function allows selecting the total for a numeric column. It calculates the sum of all values in a column.
* Example: `mysql> SELECT SUM(daily_typing_pages) FROM employee_tbl;`
These functions are crucial for performing analytical operations and data retrieval within MySQL using PHP. They allow developers to summarize and manipulate data efficiently.
In simple words: PHP has many special tools, called MySQLi functions, that help it talk to MySQL databases. These tools, which came with PHP 5.0.0, let you do things like count records, find the biggest or smallest number, calculate averages, and sum up numbers in your database. Each tool has a specific job to help manage your data.

🎯 Exam Tip: When discussing MySQL functions, include several aggregate functions (COUNT, MAX, MIN, AVG, SUM) and provide a clear SQL example for each to demonstrate their usage.

 

Question 2. Explain the Database error handling and management process in PHP?
Answer: Database error handling in PHP is crucial for creating stable and user-friendly applications. When an error occurs during database operations, PHP provides mechanisms to catch and manage these issues, preventing your application from crashing or showing sensitive information to users. The process involves:
* When an error occurs, depending on your configuration settings, PHP usually displays an error message directly in the web browser. This message includes information related to the specific error that occurred, which is helpful for developers during testing.
* PHP offers several ways to handle these errors, allowing developers to choose the best approach for their application.
* We typically look at three commonly used methods for error handling:
* **Die statements:** The `die()` function combines `echo` (to print a message) and `exit()` (to stop the script). This is very useful when you need to display an error message and immediately stop the script's execution because a critical error has occurred, like a failed database connection. For example, `die("Connection failed: " . mysqli_connect_error());`
* **Custom error handlers:** These are functions that developers create themselves to handle errors in a personalized way. When an error happens, instead of PHP's default behavior, your custom function is called. This allows for logging errors, displaying custom messages, or performing other actions.
* **PHP error reporting:** PHP has settings that control how errors are reported. This method is very useful in a development environment because it shows detailed information about the error, helping you understand what caused the problem. The information displayed can significantly help you debug your application.
Proper error handling ensures that users see helpful messages instead of raw error codes and that developers can efficiently find and fix issues.
In simple words: When there's a problem with a database in PHP, the system can show error messages to help fix it. You can make the program stop and show an error message (using `die`), create your own special way to deal with errors, or use PHP's built-in error reporting to see all the details. Good error handling keeps your website working smoothly and helps you find bugs easily.

🎯 Exam Tip: Detail PHP's default error display and then explain `die()` statements, custom error handlers, and PHP error reporting as key management techniques.

 

Question 3. Explain in details types of MySQL connection method in PHP.
Answer: PHP offers several methods for connecting to a MySQL database, each with its own advantages and recommended use cases. Choosing the right method depends on the PHP version, project requirements, and desired level of security and flexibility.
**Open a Connection to MySQL**
There are several methods for connecting to a MySQL database using PHP:
* **MySQL Improved (MySQLi) extension:** This is the most recommended method for newer PHP applications. The MySQLi extension uses the `mysqli` class, which provides an object-oriented interface along with a procedural interface for interacting with MySQL databases. It offers enhanced features, prepared statements for security, and better performance.
* **PDO (PHP Data Objects):** PDO is a database access layer that provides a uniform way to access multiple database types, including MySQL. It's highly flexible and supports prepared statements, making it very secure. PDO allows you to write code that works with different databases by just changing the connection string and driver.
* **Legacy MySQL (mysql_) functions:** These are older functions (e.g., `mysql_connect()`, `mysql_query()`) that were widely used in the past. However, they have been deprecated in PHP 5.5 and removed in PHP 7.0 due to security concerns and lack of modern features. They should only be used for backward compatibility with very old systems and avoided for new development.
* **Connecting to a remote MySQL database using PHP:** While the above methods primarily discuss the API, connecting to a remote database involves configuring the connection parameters to point to a server that is not on the same machine as the PHP script. This requires careful network setup and security considerations.
* The previous examples assume the PHP script runs on the same server where the MySQL database is located. This is common for local development.
* However, if you want to use PHP to connect to a MySQL database from a remote location, such as from another web server or your home computer, you need to specify the remote server's address.
* For example, you might connect to your A2 Hosting database from a home computer. This requires the database server to be configured to allow remote connections from your PHP server's IP address.
For new projects, MySQLi or PDO are the preferred methods due to their security features and broader capabilities. Using `mysql_` functions is highly discouraged.
In simple words: PHP has different ways to connect to a MySQL database. The best ways are MySQLi and PDO because they are safer and newer. MySQLi is just for MySQL, while PDO can work with many types of databases. There are also older methods, but they are not safe for new projects. You can connect to databases on the same computer or on a different computer, but remote connections need more security setup.

🎯 Exam Tip: List MySQLi, PDO, and legacy `mysql_` functions as the main methods. For each, describe its key characteristics, benefits, and recommended usage (or why it should be avoided).

 

Question 4. Explain MySQLi Queries with examples.
Answer: MySQLi queries are the primary way PHP scripts interact with MySQL databases to perform operations like retrieving, adding, updating, or deleting data. The main goal of MySQL and PHP connectivity is to manipulate data stored on the database server. The `mysqli_query()` function is central to this process as it helps execute SQL statements written in the PHP scripting language.
**Performing Queries:**
The `mysqli_query()` function is used to send an SQL query to the database. It requires a database connection object and the SQL query string.
**Syntax:**
`mysqli_query("Connection Object", "SQL Query")`
**Example:**
Let's say you want to connect to a database and then retrieve student names and ages. Here’s how you would do it:
`$con = mysqli_connect("localhost", "my_user", "my_password", "Student_DB");`
`$sql = "SELECT student_name, student_age FROM student";`
`mysqli_query($con, $sql);`
In this example, `$con` holds the connection to `Student_DB`, and `$sql` contains the `SELECT` query. The `mysqli_query()` function then executes this query.
**Closing Connection:**
After all database operations are complete, it is good practice to close the connection to free up server resources. The `mysqli_close()` function is used for this purpose.
**Syntax:**
`mysqli_close("Connection Object");`
**Example:**
After running queries, you can close the connection like this:
``$con = mysqli_connect("localhost", "$user", "$password", "SCHOOLDB");`
`// ....some PHP code...`
`mysqli_close($con);`
`?>`
**Example of a PHP and MySQL Program:**
This demonstrates a simple complete program connecting, querying, and closing:
``$servername = "localhost";`
`$username = "username";`
`$password = "password";`
`$dbname = "schoolDB";`
`// Create connection`
`$connection = mysqli_connect($servername, $username, $password, $dbname);`
`if (mysqli_connect_error()) {`
` echo "Failed to connect to MySQL: " . mysqli_connect_error();`
` exit(); // Stop script if connection fails`
`}`
`// SQL select query`
`$sql_stmt = "SELECT id, name FROM mycontacts";`
`$result = mysqli_query($connection, $sql_stmt);`
`// Get number of rows returned`
`$rows = mysqli_num_rows($result);`
`if ($rows > 0) {`
` while ($row = mysqli_fetch_array($result)) {`
` echo 'ID:' . $row['id'] . '
';`
` echo 'Name:' . $row['name'] . '
';`
` }`
`}`
`// Close connection`
`mysqli_close($connection);`
`?>`
This program first establishes a connection, then executes a `SELECT` query, processes the results, and finally closes the database connection. This full lifecycle is typical for database interactions in PHP.
In simple words: MySQLi queries are how PHP tells a database what to do, like getting or changing data. You use `mysqli_query()` with your database connection and the command you want to run. After you are done, you should use `mysqli_close()` to end the connection. A full program connects, asks for data, shows it, and then disconnects, checking for errors along the way.

🎯 Exam Tip: Provide the `mysqli_query()` syntax and a clear `SELECT` example. Crucially, also include a basic full program that shows the entire process from connection, query execution, result handling, to connection closure, incorporating error checks.

 

Question 1. Write the Syntax for MySQLi Queries.
Answer: The syntax for MySQLi queries involves the `mysqli_query` function, which takes parameters to connect to the database and specify the SQL query. This function is essential for sending commands to the MySQL server and getting results back.
Syntax:
`mysqli_query("Connection Object", "SQL Query")`

In simple words: To ask the database something, you use a special command called `mysqli_query`. You tell it which connection to use and what you want to ask in a simple instruction called a query string.

🎯 Exam Tip: Remember to always include both the connection object and the SQL query string as parameters when using `mysqli_query` to ensure the query is executed on the correct database connection.

 

Question 2. Write is the purpose of MySQLi function available.
Answer: MySQLi functions are used in PHP to interact with MySQL databases. Their main purposes are:

• MySQLi is a special tool in PHP that helps your PHP code talk to the MySQL database.
• These functions are made to help PHP communicate with MySQL easily and effectively.
• The `mysqli_query()` function is particularly important as it runs commands (queries) on the database. This allows PHP applications to create, read, update, and delete data in a MySQL database.

In simple words: MySQLi functions let PHP programs connect to and control MySQL databases. They are like a bridge that helps PHP tell the database what to do.

🎯 Exam Tip: When discussing the purpose of MySQLi functions, highlight their role as an "extension" and their ability to "communicate" and "perform queries" against a MySQL database.

 

Question 3. Differentiate mysqli_affected_rows() Function and mysqli_fetch_assoc() Function.
Answer: The `mysqli_affected_rows()` function and `mysqli_fetch_assoc()` function serve different purposes when working with MySQL databases in PHP. `mysqli_affected_rows()` tells you how many rows were changed by your last query, while `mysqli_fetch_assoc()` helps you get data from the database.

In simple words: `mysqli_affected_rows()` tells you how many rows were changed by your last database command. `mysqli_fetch_assoc()` helps you take information from the database and organize it like a list with names for each piece of data.

🎯 Exam Tip: Clearly state the primary purpose of each function: `affected_rows` for changes to data, and `fetch_assoc` for retrieving data, mentioning the associative array format for clarity.

 

Question 4. Write MySQL Connection Syntax with example.
Answer: Establishing a connection to a MySQL database in PHP is the first step before performing any database operations. The `mysqli_connect()` function is used for this purpose, taking parameters like server name, username, password, and database name.
Syntax:
`mysqli_connect("Server Name", "User Name", "password", "DB Name");`
Example:
``$servername = "localhost";`
`$username = "username";`
`$password = "password";`
`$DB_name = "SchooLDB";`
`// Create connection`
`$conn = mysqli_connect($servername, $username, $password, $DB_name);`
In simple words: To link your PHP program to a MySQL database, you use a special command called `mysqli_connect()`. You need to tell it details like where the database is, your username, password, and the database name.

🎯 Exam Tip: When providing a connection example, make sure to include all four essential parameters: server, username, password, and database name, and explain that these define how the PHP script accesses the database.

 

Question 5. Write a note PHP MySQL database connection.
Answer: PHP MySQL database connection refers to how a PHP script links up with a MySQL database to send and receive data. This connection allows web applications to store and retrieve information dynamically.

• The combination of PHP and MySQL has become a very popular server-side web scripting language setup on the Internet. Many websites use this powerful duo.
• MySQL and PHP scripting language connectivity involves several stages: establishing the database connection, selecting the correct database, executing SQL statements, and finally terminating the connection.

In simple words: PHP and MySQL work together very well for websites. Connecting them means your website can store and get information from a database, which makes the website dynamic and useful.

🎯 Exam Tip: When explaining PHP MySQL connections, emphasize their popularity for web scripting and mention the key stages involved: establishment, selection, execution, and termination of the connection.

 

Question 1. Discuss in detail MySQL functions for example.
Answer: MySQL provides many functions that can be used with PHP scripting language for database connectivity and running SQL queries. These functions help in managing and manipulating data effectively.

• MySQLi is an important extension in PHP that lets you access MySQL databases.
• The MySQLi extension was added in PHP version 5.0.0, bringing improved features.
• Some important MySQL functions include:
  • **MySQL COUNT Function:** This function is used to count how many rows are in a database table.
    Example: `mysql> SELECT COUNT(*) FROM employee_tbl;`
  • **MySQL MAX Function:** This function finds the highest (maximum) value in a specific column.
    Example: `mysql > SELECT MAX(daily_typing_pages) FROM employee_tbl;`
  • **MySQL MIN Function:** This function finds the lowest (minimum) value in a specific column.
    Example: `MySQL > SELECT MIN(daily_typing_pages) FROM employee_tbl;`
  • **MySQL AVG Function:** This function calculates the average value for a specific column.
    Example: `MySQL > SELECT AVG(daily_typing_pages) FROM employee_tbl;`
  • **MySQL SUM Function:** This function adds up all the values in a numeric column.
    Example: `MySQL > SELECT SUM(daily_typing_pages) FROM employee_tbl;`

In simple words: MySQL has many functions that help you do things with your data, like counting how many items you have, finding the biggest or smallest number, getting an average, or adding everything up. These are often used with PHP to build web applications.

🎯 Exam Tip: When discussing MySQL functions, list several common aggregate functions (COUNT, MAX, MIN, AVG, SUM) and provide a clear, simple example for each to illustrate their usage.

 

Question 2. Explain the Database error handling and management process in PHP?
Answer: In PHP, managing and handling errors in database operations is crucial for building robust applications. PHP offers several ways to handle errors, and the way errors are displayed depends on the server settings.

• When an error happens, PHP can show an error message in the web browser, giving information about what went wrong.
• PHP has multiple methods for dealing with errors, ensuring that issues can be caught and managed.
• One common method is "Die statements":
  • The `die()` function combines `echo` (to print a message) and `exit` (to stop the script).
  • This is very useful for showing an error message and immediately stopping the script if a critical error occurs, like a failed database connection.
• "Custom error handlers" are functions you can create to manage errors yourself when they happen.
• "PHP error reporting" determines what kind of error messages PHP shows.
  • The error message depends on the PHP error reporting settings that are configured.
  • This method is very helpful during development, as it shows detailed information about the error, which helps in fixing it.
  • The information displayed helps you find and fix problems in your application.

In simple words: PHP has special ways to deal with problems that happen when it tries to use a database. It can show messages about errors, stop the program, or let you create your own ways to handle errors, which helps programmers fix problems quickly.

🎯 Exam Tip: Focus on the different error handling mechanisms: displaying error messages, using `die()` statements for critical failures, and custom error handlers. Emphasize their importance for debugging and application stability.

 

Question 3. Explain in details types of MySQL connection method in PHP.
Answer: There are several methods for connecting to a MySQL database using PHP, each with its own advantages and use cases. These methods allow developers to choose the best option for their specific project requirements.
Open a Connection to MySQL:

• **MySQL Improved (MySQLi) extension:** This is the most recommended method. It uses the `mysqli` class, which offers improved features and replaces older MySQL functions. It supports both procedural and object-oriented ways of working.
• **PDO (PHP Data Objects):** PDO provides a lightweight, consistent interface for accessing many different databases. While MySQLi is specific to MySQL, PDO can work with various database types, making code more flexible for different database systems.
• **Legacy MySQL (mysql_) functions:** These are older functions that have been deprecated (marked as outdated) in PHP 5.5 and will eventually be removed. They should generally be avoided for new projects unless absolutely necessary for backward compatibility with very old code.
• **Connecting to a remote MySQL database:** All the methods above can be adapted to connect to a database on a different server, not just the one where the PHP script is running. This is common for production environments where the web server and database server are separate machines.

In simple words: PHP can connect to MySQL databases in different ways. The `MySQLi` way is the best and newest. `PDO` is also good because it can connect to many types of databases. Older `mysql_` methods should not be used anymore. You can also connect to databases that are on a different computer.

🎯 Exam Tip: When explaining connection methods, always highlight MySQLi as the primary recommendation due to its improved features. Mention PDO for its versatility across database types and stress that legacy `mysql_` functions are deprecated and should not be used in new development.

 

Question 4. Explain MySQLi Queries with examples.
Answer: MySQLi queries are commands used to interact with a MySQL database from a PHP script. Their main purpose is to retrieve, change, or organize data. The `mysqli_query()` function is central to executing these SQL statements.
Performing Queries:
The main goal of MySQL and PHP working together is to get and change data in the MySQL database. SQL query statements help PHP's MySQLi extension achieve this. The `mysqli_query()` function helps to run the SQL query statements in the PHP scripting language.
Syntax:
`mysqli_query("Connection Object", "SQL Query")`
Example:
`$con = mysqli_connect("localhost", "my_user", "my_password", "Student_DB");`
`$sql = "SELECT student_name, student_age FROM student";`
`mysqli_query($con, $sql);`
Closing Connection:
After performing database operations, it's important to close the connection to free up resources. The `mysqli_close()` function is used for this purpose.
`mysqli_close()` Function is used to close an existing opened database connection between PHP scripting and MySQL Database Server.
Syntax:
`mysqli_close("Connection Object");`
Example of a PHP and MySQL Program:
``$servername = "localhost";`
`$username = "username";`
`$password = "password";`
`$dbname = "schoolDB";`
`$connection = mysqli_connect($servername, $username, $password, $dbname);`
`if (mysqli_connect_error()) {`
` echo "Failed to connect to MySQL: ";`
` mysqli_connect_error();`
`}`
`$sql_stmt = "SELECT * FROM mycontacts"; //SQL select query`
`$result = mysqli_query($connection, $sql_stmt); //execute SQL statement`
`$rows = mysqli_num_rows($result); // get number of rows returned`
`if($rows) {`
` while ($row = mysqli_fetch_array($result)) {`
` echo 'ID:' . $row['id'] . '
';`
` }`
`}`
`// ....some PHP code...`
`mysqli_close($connection);`
`?>`In simple words: MySQLi queries are like instructions you give to a database from your PHP code. You use `mysqli_query()` to run these instructions, like `SELECT` to get data or `INSERT` to add data. After you are done, `mysqli_close()` is used to shut down the connection.

🎯 Exam Tip: When explaining MySQLi queries, include the `mysqli_query()` function for execution, provide a simple `SELECT` query example, and also demonstrate the `mysqli_close()` function for proper connection termination.

 

Question 1. The combination of PHP and MYSQL has become very popular ______ web scripting language on the internet.
Answer: Server-side
In simple words: PHP and MySQL are a popular team for making websites work on the server, meaning behind the scenes, not directly in your web browser.

🎯 Exam Tip: Remember that server-side scripting processes data on the web server before sending it to the user's browser, making PHP and MySQL ideal for dynamic web content.

 

Question 2. Which of the following is not an RDBMS?
(a) Oracle
(b) IBM DB2
(c) Microsoft SQLSERVER
(d) None of these
Answer: (d) None of these
In simple words: All the options like Oracle, IBM DB2, and Microsoft SQL Server are types of RDBMS. So, none of them are *not* RDBMS.

🎯 Exam Tip: Be familiar with common RDBMS examples like Oracle, MySQL, PostgreSQL, SQL Server, and IBM DB2 to correctly identify them.

 

Question 3. Which is used to convert PHP code into C++?
(a) LPLP
(b) HPHP
(c) BPBP
(d) APAP
Answer: (b) HPHP
In simple words: HPHP is a tool that takes PHP code and changes it into C++ code, which can sometimes make PHP programs run faster.

🎯 Exam Tip: Recall that HPHP (now HipHop Virtual Machine or HHVM) was developed by Facebook to convert PHP to C++ for performance improvements.

 

Question 4. _______ is a function, helps to execute the SQL query statements in PHP scripting language.
(a) mysqli_close()
(b) mysqli_connect_error()
(c) mysqli_query()
(d) mysqli_connect()
Answer: (c) mysqli_query()
In simple words: The `mysqli_query()` command is the one you use in PHP to send SQL instructions to the database, like asking for information or making changes.

🎯 Exam Tip: Distinguish between connection functions (`mysqli_connect`), error handling (`mysqli_connect_error`), closing (`mysqli_close`), and query execution (`mysqli_query`).

 

Question 5. Which of the following has written an alternative version of PHP?
(a) Facebook
(b) Twitter
(c) Instagram
(d) Whatsapp
Answer: (a) Facebook
In simple words: Facebook created its own special version of PHP to make their website run faster, called HipHop Virtual Machine (HHVM).

🎯 Exam Tip: Remember Facebook's contribution to PHP performance with HHVM, which optimized PHP by converting it to C++.

 

Question 1. RDMS stands ___________.
Answer: Relational Database Management System
In simple words: RDMS is a system that organizes data into tables and lets you link related information together, like a well-organized set of lists.

🎯 Exam Tip: Know the full form of common acronyms in computer science, especially those related to databases like RDBMS and SQL.

 

Question 2. SQL stands ___________.
Answer: Structure query language
In simple words: SQL is a special language used to talk to databases, allowing you to ask questions or give commands to get or change data.

🎯 Exam Tip: Understand that SQL is the standard language for managing and querying relational databases.

 

Question 3. MySQLi extension was introduced version ___________.
Answer: 5.0.0
In simple words: The improved way to connect PHP to MySQL (MySQLi) was first made available starting from PHP version 5.0.0.

🎯 Exam Tip: Remembering key version numbers for important extensions like MySQLi can be helpful for historical context and compatibility discussions.

 

Question 4. ___________ is an extension in PHP scripting language which gives access to the MYSQL database.
Answer: MySQLi
In simple words: MySQLi is a special tool added to PHP that allows your PHP code to easily connect and work with a MySQL database.

🎯 Exam Tip: Emphasize that MySQLi is the improved and recommended extension for PHP-MySQL interaction.

 

Question 5. Connect function requires ___________ a number of parameters to connect to database server.
Answer: four
In simple words: To connect to a database, the `connect` function needs four pieces of information: the server name, username, password, and the database name.

🎯 Exam Tip: Memorize the four essential parameters for a basic `mysqli_connect()` call: server, user, password, and database.

 

Question 1. Choose the incorrect statements:
a) PHP is an Open source & Community support scripting language
b) PHP is a server-side scripting language designed for Web development.
c) Only twenty Percentage of Website has been built by PHP and MySQL
d) Data is important to all computer and Internet-related applications.
Answer: (c) Only twenty Percentage of Website has been built by PHP and MySQL
In simple words: Many more than twenty percent of websites use PHP and MySQL, so saying "only twenty percent" is wrong.

🎯 Exam Tip: Be aware of common misconceptions or outdated statistics. PHP and MySQL power a significant portion of the web, far more than 20%.

 

Question 2. Choose the incorrect statements:
a) mysqli_connect() function requires two parameters to connect to the database server.
b) Major of the web servers can support PHP scripting language
c) PHP can embed easily with HTML and client-side scripting language
d) PHP has a built-in function which is easily connected to the MySQL database
Answer: (a) mysqli_connect() function requires two parameters to connect to database server.
In simple words: The `mysqli_connect()` function needs four pieces of information (parameters) to work, not just two, so this statement is incorrect.

🎯 Exam Tip: Always remember that `mysqli_connect()` typically needs four parameters (server, username, password, database name), not just two.

 

Question 3. Choose the incorrect statements:
a) PHP scripting language has been supported by many Software frameworks
b) MySQLi is extension in HTML.
c) MySQLi gives access to the MYSQL database.
d) MySQLi extension was introduced in version 5.0.0.
Answer: (b) MySQLi is extension in HTML.
In simple words: MySQLi is a PHP extension for databases, not an HTML extension. HTML is for building web pages, not database connections.

🎯 Exam Tip: Clearly differentiate between programming languages (PHP), database extensions (MySQLi), and markup languages (HTML) and their respective roles.

 

Question 4. Choose the incorrect statements:
a) mysqli_connect() function is used to connect to database server
b) If the connection gets fails, the output will be printed with MySQL error code.
c) If the connection gets true, there is no output to display.
d) The main goal of HTML and PHP connectivity is to retrieve and manipulate the data
Answer: (c) If the connection gets true, there is no output to display.
In simple words: When a database connection works, there is usually no output unless the programmer specifically writes code to show a "success" message. This statement says there is *no* output, which is generally true for a successful connection unless programmed otherwise. However, the question asks for *incorrect* statements. The main goal of HTML and PHP connectivity is *not* to manipulate data (that's PHP and MySQL), HTML's goal is structuring content. So (d) is also problematic. Given the provided answer (c), it implies that a successful connection *could* have output if explicitly programmed for success. Let's stick to the provided answer.

🎯 Exam Tip: A successful database connection typically yields no direct output unless explicitly programmed to do so. Error messages are produced only on failure.

 

Question 5. Choose the incorrect statements:
a) The SQL query statements are helping with PHP MySQL extension
b) mysqli_connect() function, helps to execute the SQL query statements in PHP scripting language
c) MySQL is an open-source relational database management system.
d) mysqli_close() function requires two parameters to close an existing opened database connection
Answer: (d) mysqli_close() function requires two parameters to close an existing opened database connection
In simple words: The `mysqli_close()` function only needs one piece of information, which is the connection object itself, to close the database link. It does not need two.

🎯 Exam Tip: Remember that `mysqli_close()` takes only one parameter: the connection object, to correctly close the database connection.

 

Question 1. Mention Some RDBMS Softwares?
Answer: Relational Database Management System (RDBMS) softwares include popular options such as MySQL, Oracle, IBM DB2, and Microsoft SQLSERVER. These systems are designed to manage data stored in relational tables efficiently.In simple words: Some popular programs that manage databases using tables and links are MySQL, Oracle, IBM DB2, and Microsoft SQL Server.

🎯 Exam Tip: Be able to list at least three major RDBMS products as common examples in database discussions.

 

Question 2. What is MySQLi?
Answer: MySQLi stands for "MySQL Improved." It is an extension in the PHP scripting language that provides an enhanced interface for interacting with MySQL databases. This extension offers both procedural and object-oriented APIs.In simple words: MySQLi is a better and newer way for PHP programs to connect to and work with MySQL databases.

🎯 Exam Tip: Define MySQLi as an "improved extension" in PHP for "accessing MySQL databases" and mention its support for both procedural and object-oriented styles if possible.

 

Question 3. What are the major operations of the database?
Answer: The major operations performed on a database, often referred to as CRUD operations, are:

• INSERT: Adding new data records into a table.
• SELECT: Retrieving specific data from one or more tables.
• UPDATE: Modifying existing data records in a table.
• DELETE: Removing data records from a table.

In simple words: The main things you do with a database are add new information, find information, change existing information, and remove information.

🎯 Exam Tip: Always remember the four fundamental database operations: INSERT (create), SELECT (read), UPDATE, and DELETE (CRUD).

 

Question 4. How many parameters to connect to the database server in Mysqli_connect() Function?
Answer: The `mysqli_connect()` function requires four parameters to establish a connection to the database server. These parameters are essential for identifying the server, authenticating the user, and specifying the database to connect to.In simple words: The `mysqli_connect()` command needs four pieces of information to link up with a database: the server name, username, password, and database name.

🎯 Exam Tip: Clearly state "four parameters" and, if asked, be ready to list them: server, username, password, and database name.

 

Question 5. What is the mash goal of MySQL and PHP connectivity?
Answer: The primary goal of MySQL and PHP connectivity is to retrieve and manipulate data from the MySQL database server. This allows dynamic web applications to interact with data, providing features like user registration, content management, and e-commerce functionalities.In simple words: The main reason to connect MySQL and PHP is to get information from the database and make changes to it. This helps build websites that can show different content to different users.

🎯 Exam Tip: Highlight the two core actions: "retrieve" and "manipulate" data, which are the essence of dynamic web applications using PHP and MySQL.

 

Question 1. Find the odd one on the following
a) MySQL
b) Java
c) DB2
d) Oracle
Answer: (b) Java
In simple words: Java is a programming language, while MySQL, DB2, and Oracle are all types of database management systems. So, Java is the different one.

🎯 Exam Tip: Always categorize items first. Here, the options include programming languages and database systems; the "odd one out" will belong to a different category.

 

Question 2. Find the odd one on the following
a) TRUNCATE
c) UPDATE
b) SELECT
d) INSERT
Answer: (a) TRUNCATE
In simple words: TRUNCATE is a Data Definition Language (DDL) command that removes all rows from a table, while UPDATE, SELECT, and INSERT are Data Manipulation Language (DML) commands that interact with existing data.

🎯 Exam Tip: Differentiate between DDL (Data Definition Language) commands like TRUNCATE, CREATE, ALTER, DROP, and DML (Data Manipulation Language) commands like INSERT, SELECT, UPDATE, DELETE.

 

Question 3. Find the odd one on the following
a) $servername
b) $client name
c) $username
d) $password
Answer: (c) $username
In simple words: The variable `$client name` is not a standard parameter for establishing a MySQLi connection. The correct ones are servername, username, and password.

🎯 Exam Tip: Familiarize yourself with the exact names of common variables and parameters used in database connections. `$client name` is not standard, while server name, username, and password are.

 

Question 4. Find the odd one on the following
a) Mysqli_connect() Function
b) Mysqli_close() Function
c) Mysqli_create_db() Function
d) Mysqli_select_db() Function
Answer: (c) Mysqli_create_db() Function
In simple words: There is no `mysqli_create_db()` function in MySQLi. Database creation is typically done using SQL statements like `CREATE DATABASE` executed via `mysqli_query()`. The other options are valid functions.

🎯 Exam Tip: Be aware that while `mysqli_connect()` and `mysqli_close()` exist, direct functions for `create_db` or `select_db` (like the deprecated `mysql_select_db`) are not part of the standard MySQLi API; instead, `mysqli_query()` is used with SQL `CREATE DATABASE` or `USE DATABASE` statements.

 

Question 5. Find the odd one on the following
a) MysqlLaffected_rows() Function
b) Mysqli_connect_error() Function
c) Mysqli_fetch_assoc() Function
d) Mysqli_delete_db() Function
Answer: (d) Mysqli_delete_db() Function
In simple words: The `mysqli_delete_db()` function does not exist in the MySQLi extension. To delete a database, you would use an SQL command like `DROP DATABASE` with `mysqli_query()`. The other functions are valid.

🎯 Exam Tip: Recognize that database manipulation actions like creating or deleting a database are typically performed using SQL commands executed via `mysqli_query()`, rather than dedicated MySQLi functions for these specific tasks.

 

Question 1. Match the following
A) DB2 – 1) Connect database server
B) INSERT – 2) RDBMS
C) Mysqli_close() Function – 3) One of the major operation
D) Mysqli_connect() Function – 4) Close an existing opened database
Answer: (c) 2 3 4 1
In simple words: This means: DB2 is an RDBMS (2), INSERT is a major database operation (3), `mysqli_close()` closes a database connection (4), and `mysqli_connect()` connects to a database server (1).

🎯 Exam Tip: For matching questions, systematically go through each item and its definition. Grouping similar concepts (e.g., database types, operations, functions) can help.

 

Question 2. Match the following
A) DB2 -1) Open source
B) SQLSERVER – 2) IBM
C) MySQL – 3) Microsoft
D) Oracle – 4) Oracle Corporation
Answer: (a) 2 3 1 4
In simple words: This means: DB2 is from IBM (2), SQLSERVER is from Microsoft (3), MySQL is open-source (1), and Oracle is from Oracle Corporation (4).

🎯 Exam Tip: Know the primary developers or characteristics associated with major database systems. IBM for DB2, Microsoft for SQL Server, open-source for MySQL, and Oracle Corporation for Oracle Database.

 

Question 3. Match the following
A) Mysqli_close() Function -1) Four parameters
B) Mysqli_connect() Function -2) Two parameters
C) mysqli_query() Function -3) No parameters
D) mysqli_connect_errno() -4) One Parameter
Answer: (d) 4 1 2 3
In simple words: This means: `mysqli_close()` needs one parameter (4), `mysqli_connect()` needs four parameters (1), `mysqli_query()` needs two parameters (2), and `mysqli_connect_errno()` needs no parameters (3).

🎯 Exam Tip: Accurately recall the number of parameters required for common MySQLi functions, especially `connect` (4), `query` (2), `close` (1), and error functions (often 0 or 1).

 

Question 4. Match the following
A) Mysqli_close() Function -1) Fetches a result row
B) Mysqli_connect() Function -2) To execute the SQL query
C) mysqli_query() Function -3) To connect to database server
D) mysqli_fetch_assoc() -4) To close an existing opened database
Answer: (b) 4 3 2 1
In simple words: This means: `mysqli_close()` closes a database (4), `mysqli_connect()` connects to a database server (3), `mysqli_query()` runs an SQL query (2), and `mysqli_fetch_assoc()` gets a result row (1).

🎯 Exam Tip: Match each function to its core purpose: `connect` for establishing, `close` for terminating, `query` for executing SQL, and `fetch_assoc` for retrieving data rows.

 

Question 5. Match the following
A) mysqli_affected_rows()Returns the number of affected rows
B) mysqli_connect_error() – Returns the error description
C) MySQL MAX Function – Select the highest value for a certain column.
D) MySQL MIN Function- – Select the lowest value for a certain column.
Answer: (b) 1 2 3 4
In simple words: This means all the matches are correct as listed: `mysqli_affected_rows()` returns the number of rows changed (1), `mysqli_connect_error()` returns the error message (2), MySQL MAX finds the highest value (3), and MySQL MIN finds the lowest value (4).

🎯 Exam Tip: Confirm that each function or command correctly matches its description. Pay attention to keywords like "affected rows," "error description," "highest value," and "lowest value."

 

Question 1. What is MySQL?
Answer: MySQL is a popular open-source relational SQL database management system (RDBMS). It is widely used for web-based software and applications to store, manage, and retrieve data efficiently.In simple words: MySQL is a free and popular program that helps organize and store data in tables, which is often used for websites and apps.

🎯 Exam Tip: Key points for defining MySQL are "open-source," "relational database," "SQL," and its common use in "web applications."

 

Question 2. Write a Snippet code to check database connection?
Answer: To check if a database connection in PHP was successful, you can use an `if` statement to look for connection errors. If an error occurs, the script can stop and display an error message.
``// Assume $conn is your connection object from mysqli_connect()`
`if(!$conn){`
` die("Connection failed: " . mysqli_connect_error());`
`}`
`echo "Connected successfully";`
`?>`In simple words: You can check if your database connection worked by using an `if` statement. If it didn't connect, a message will appear, and the program will stop. If it worked, you can show a "Connected successfully" message.

🎯 Exam Tip: The `if(!$conn)` condition checks for a false connection, and `die(mysqli_connect_error())` is a crucial pattern for stopping execution and reporting the exact connection failure.

 

Question 3. What is the use of SQL statements in PHP?
Answer: SQL statements are used in PHP to communicate with and control a MySQL database. They allow PHP to perform essential database operations. SQL statements are like commands that tell the database what to do.
The SQL query statements help with the PHP MySQL extension to achieve the objective of MySQL and PHP connection. They enable PHP to retrieve data, insert new records, update existing information, or delete records from the database.In simple words: SQL commands help PHP talk to the database. They tell the database to get information, put new information in, change information, or take information out.

🎯 Exam Tip: Emphasize that SQL statements are the language for "interacting with databases" (retrieving, manipulating, defining data) and are crucial for "PHP MySQL connectivity."

 

Question 4. How the connection will get success in the mysqli_connect() function?
Answer: A connection using the `mysqli_connect()` function becomes successful when the PHP script can successfully establish a link with the MySQL database server using the provided credentials.

• The MySQL `connect` function uses server, username, password, and database name variables to connect to the Database server from PHP scripting.
• If the connection fails for any reason (e.g., wrong credentials, server offline), an output with a MySQL error code will be printed.
• Otherwise, if all details are correct and the server is reachable, the connection is considered a success, and the function returns a connection object.

In simple words: The `mysqli_connect()` works when all the details you give it, like the server address, your username, and password, are correct and the database server is running. If anything is wrong, it will show an error.

🎯 Exam Tip: A successful connection requires correct parameters (server, user, password, db name) and a reachable database server. Highlight that failure results in an error code, while success typically proceeds silently or with a custom success message.

 

Question 1. Write any 3 special features of PHP?
Answer: PHP is a versatile and widely used scripting language known for several key features that make it popular for web development. These features contribute to its ease of use and powerful capabilities.

1. PHP can easily be mixed with HTML and client-side scripting languages like JavaScript.
2. PHP has built-in functions that make it simple to connect to a MySQL database without writing complex code.
3. PHP is a scripting language that has strong support from many software frameworks, such as Laravel and Symfony, which help developers build web applications faster.

In simple words: PHP is good because it works well with HTML, has ready-made tools to connect to databases like MySQL, and many other software tools support it.

🎯 Exam Tip: When listing PHP features, focus on its web development strengths: ease of embedding with HTML, native database connectivity, and strong framework support.