1) Define serialization.

2) Write the syntax for creating Cookie.

To create a cookie in PHP, you can use the `setcookie()` function. Below is the syntax for creating a
cookie in PHP:

```php
setcookie(name, value, expire, path, domain, secure, httponly);
```

Here's a breakdown of each parameter:

- `name`: The name of the cookie.

- `value`: The value of the cookie.
- `expire`: The expiration time of the cookie (in Unix timestamp format). If set to `0`, the cookie will
expire at the end of the session. If not specified, the cookie will expire when the browser is closed.
- `path`: The path on the server where the cookie will be available. If set to `'/'`, the cookie will be
available throughout the entire domain.
- `domain`: The domain name where the cookie will be available. If not specified, the cookie will be
available on the current domain only.
- `secure`: A boolean value indicating if the cookie should only be transmitted over HTTPS.
- `httponly`: A boolean value indicating if the cookie should be accessible only through HTTP protocol
and not through JavaScript.

Here's an example of creating a cookie in PHP:

```php
// Set a cookie named 'username' with the value 'JohnDoe'
setcookie('username', 'JohnDoe', time() + 3600, '/');

echo 'Cookie created successfully!';

```

3) State the use of cloning of an object.

In PHP, the cloning of an object is done using the `clone` keyword. When you clone an object in PHP,
you create a copy of the object with separate memory allocation. Here's how you can use cloning in
PHP:

1. **Basic Cloning Syntax**:

```php
$objectCopy = clone $originalObject;
```

This syntax creates a copy of the `$originalObject` and assigns it to `$objectCopy`.

2. **Example**:
```php
class MyClass {
public $data;

public function __construct($data) {

$this->data = $data;
}
}

// Create an instance of MyClass

$obj1 = new MyClass('Hello');

// Clone the object

$obj2 = clone $obj1;

// Modify data in the clone

$obj2->data = 'World';

// Display original and cloned data

echo $obj1->data; // Output: Hello
echo $obj2->data; // Output: World
```
4) Define the GET and POST methods.
5) Differentiate between Session and Cookies.

6) List out the database operations.

-Database is a collection of related data.

- We can organize large amount of data in database so that we can easily access it.
- DBMS is a system software for creating and managing databases.

1.Connecting to a Database: Establish a connection to a database server using functions

like mysqli_connect() or PDO.
2.Creating a Database: Use SQL commands to create a new database, such as CREATE DATABASE
dbname.

3.Selecting a Database: Choose a specific database to work with using USE dbname.

4.Creating Tables: Define the structure of your data by creating tables with columns and data types
using CREATE TABLE.

5.Inserting Data: Add new records to a table using INSERT INTO.

6.Updating Data: Modify existing data in a table using UPDATE.

7.Retrieving Data (Select Query): Retrieve specific data from one or more tables using SELECT.

8.Deleting Data: Remove records from a table using DELETE FROM.

9.Dropping Tables: Delete an entire table from the database using DROP TABLE.

7) Define session and explain how it works.

A session in PHP is a mechanism for storing information (such as user data or preferences) across
multiple pages during a user’s visit to a website. Unlike cookies, which are stored on the user’s
computer, session data is stored on the server.
Here’s how PHP sessions work:

Starting a Session:

A session is initiated using the session_start() function. This function must be called before any HTML
output or other content.
When a user visits a page, PHP generates a unique session ID for that user.

Session Variables:

Session variables are used to store data specific to a user’s session.

You can set session variables using the $_SESSION superglobal array.
For example:
<?phpsession_start();$_SESSION['username'] = 'john_doe';?>

Retrieving Session Data:

On subsequent pages, you can access session data using the same $_SESSION array.
For example:
<?phpsession_start();echo "Welcome, " . $_SESSION['username'];?>

Session ID and Cookies:

When a session is started, PHP sends a unique session ID to the user’s browser as a cookie.
The browser includes this session ID in subsequent requests to the server.
The server uses the session ID to retrieve the associated session data.

Session Lifetime:

By default, session variables last until the user closes their browser.
You can customize the session lifetime by modifying the session.cookie_lifetime configuration in
php.ini.

Session Security:

Session data is stored on the server, making it more secure than cookies (which can be manipulated
by the user).
However, session hijacking and session fixation attacks are still possible.
Best practices include using HTTPS, regenerating session IDs, and avoiding storing sensitive data in
sessions.
In summary, PHP sessions allow you to maintain state across multiple pages during a user’s visit by
storing data on the server and associating it with a unique session ID123.

8) Define the following terms: i) Start a session ii) Destroy a session

i) **Start a Session**:
Starting a session in PHP refers to the process of initializing or resuming a session to enable the
storage and retrieval of session data. This is typically done at the beginning of a PHP script using the
`session_start()` function. When a session is started, a unique session ID is generated for the user, and
session variables can be used to store and access data throughout the user's interaction with the web
application.

Example:
```php
<?php
session_start();
// Other PHP code here
?>
```

In this example, `session_start()` initiates a session, allowing the usage of `$_SESSION` variables to
store and retrieve data across multiple requests.

ii) **Destroy a Session**:

Destroying a session in PHP refers to ending the current session and removing all associated session
data. This is typically done using the `session_destroy()` function. When a session is destroyed, the
session ID is invalidated, and the session cookie is deleted from the user's browser. Subsequently, any
session variables and data stored during that session are no longer accessible.

Example:
```php
<?php
session_start(); // Start the session
// Code to use and manipulate session variables

// Destroy the session

session_destroy();
?>
```
 In this example, `session_destroy()` is called to end the session and clear all session data. It is
important to note that `session_destroy()` only destroys the session data on the server side; it does
not delete the session cookie on the user's browser.

9) Describe the Serialization method in detail with example

Serialization is a process in programming that involves converting complex data structures, such as
objects or arrays, into a format that can be easily stored, transmitted, or reconstructed. Serialization
is particularly useful for scenarios where data needs to be persisted to a file, sent over a network, or
stored in a database. In PHP, serialization is commonly used with the `serialize()` and `unserialize()`
functions to convert objects or arrays into strings and vice versa.

### Serialization Method in PHP:

1. **Serialize Function (`serialize()`)**:

- The `serialize()` function in PHP is used to convert an object or an array into a string representation.
- It traverses the data structure recursively and converts each element into a format that can be
stored as a string.
- The resulting serialized string can be stored in a file, database, or transmitted over a network.

Example of serializing an array:

```php
$data = array(
'name' => 'John Doe',
'age' => 30,
'email' => '[email protected]'
);

$serializedData = serialize($data);
echo $serializedData; // Output: a:3:{s:4:"name";s:8:"John
Doe";s:3:"age";i:30;s:5:"email";s:19:"[email protected]";}
```

2. **Unserialize Function (`unserialize()`)**:

- The `unserialize()` function in PHP is used to reconstruct an object or an array from a serialized
string.
- It takes a serialized string as input and converts it back into its original data structure.

Example of unserializing a string:

```php
$serializedData = 'a:3:{s:4:"name";s:8:"John
Doe";s:3:"age";i:30;s:5:"email";s:19:"[email protected]";}';

$data = unserialize($serializedData);
print_r($data); // Output: Array ( [name] => John Doe [age] => 30 [email] =>
[email protected] )
```

Serialization is useful for storing and transferring complex data structures in a compact and portable
format, making it a fundamental technique in data handling and communication in PHP applications.

10) Create a web page using GUI components

<!DOCTYPE html>
<html lang="en">
<head>
 <meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>GUI Components Example</title>
</head>
<body>
<div>
<h1>GUI Components Example</h1>
<form method="POST" action="">
<label for="name">Name:</label>
<input type="text" id="name" name="name" placeholder="Enter your name">

<label for="email">Email:</label>
<input type="email" id="email" name="email" placeholder="Enter your email">

<label for="gender">Gender:</label>
<select id="gender" name="gender">
<option value="male">Male</option>
<option value="female">Female</option>
<option value="other">Other</option>
</select>

<button type="submit">Submit</button>
</form>

<?php
// PHP code for form processing
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$name = $_POST['name'];
$email = $_POST['email'];
$gender = $_POST['gender'];

// Display submitted data

echo "<h2>Submitted Data:</h2>";
echo "<p>Name: $name</p>";
echo "<p>Email: $email</p>";
echo "<p>Gender: $gender</p>";
}
?>
</div>
</body>
</html>

11) Answer the following: i)Use of cookies ii) how to set the cookie iii) how to modify iv) how to
delete the cookies.

i) **Use of Cookies**:
Cookies are small pieces of data stored on the user's computer by the web browser. They are
commonly used for:
- Storing user preferences and settings.
- Remembering user login sessions.
- Tracking user activity and behavior.
- Personalizing content and advertisements.
- Implementing shopping carts in e-commerce websites.

Cookies allow websites to recognize users, maintain session information, and provide a personalized
browsing experience.
ii) **How to Set a Cookie**:
In PHP, you can set a cookie using the `setcookie()` function. The basic syntax for setting a cookie is
as follows:
```php
setcookie(name, value, expire, path, domain, secure, httponly);
```
- `name`: The name of the cookie.
- `value`: The value of the cookie.
- `expire`: The expiration time of the cookie (in Unix timestamp format). If set to `0`, the cookie will
expire at the end of the session. If not specified, the cookie will expire when the browser is closed.
- `path`: The path on the server where the cookie will be available. If set to `'/'`, the cookie will be
available throughout the entire domain.
- `domain`: The domain name where the cookie will be available. If not specified, the cookie will be
available on the current domain only.
- `secure`: A boolean value indicating if the cookie should only be transmitted over HTTPS.
- `httponly`: A boolean value indicating if the cookie should be accessible only through HTTP
protocol and not through JavaScript.

Example of setting a cookie:

```php
setcookie('username', 'JohnDoe', time() + 3600, '/');
```

iii) **How to Modify a Cookie**:

To modify a cookie, you can simply set a new value for the cookie using the `setcookie()` function.
The new value will overwrite the existing value of the cookie.

Example of modifying a cookie:

```php
setcookie('username', 'JaneDoe', time() + 3600, '/');
```

In this example, the value of the 'username' cookie is changed from 'JohnDoe' to 'JaneDoe'.

iv) **How to Delete Cookies**:

To delete a cookie, you can set its expiration time to a past timestamp using the `setcookie()`
function. When the expiration time is in the past, the cookie is considered expired and will be deleted
by the browser.

Example of deleting a cookie:

```php
setcookie('username', '', time() - 3600, '/');
```

In this example, the 'username' cookie is deleted by setting its expiration time to one hour ago
(`time() - 3600`).
12) Write a program to create PDF document in PHP.

13) Describe the web page validation with suitable example.

<html>
<body>
<h2>Email Validation</h2>
<form method="POST" action="">
<label for="email">Enter your email:</label>
<input type="text" id="email" name="email">
<input type="submit" value="Check">
</form>
<?php
if ($_SERVER["REQUEST_METHOD"] == "POST") {
$email = $_POST['email'];
if (filter_var($email, FILTER_VALIDATE_EMAIL)) {
echo "<p>$email is a valid email address.</p>";
} else {
echo "<p>$email is not a valid email address.</p>";
}
}
?>
</body>
</html>

14) Explain update and delete operations on table data.

1. **Update Operation**:
The update operation is used to modify existing data in a database table. It allows you to change the
values of one or more columns in one or multiple rows based on specified conditions. The basic
syntax for an update operation in SQL is as follows:

```sql
UPDATE table_name
SET column1 = value1, column2 = value2, ...
WHERE condition;
```

- `table_name`: The name of the table to update.

- `column1 = value1, column2 = value2, ...`: Specifies the columns to be updated and their new
values.
- `WHERE condition`: Optional. Specifies the condition that determines which rows to update. If
omitted, all rows in the table will be updated.

Example of an update operation:

```sql
UPDATE users
SET email = '[email protected]', status = 'active'
WHERE user_id = 123;
```

In this example, the email and status of the user with `user_id` 123 are updated to
'[email protected]' and 'active', respectively.

2. **Delete Operation**:
The delete operation is used to remove one or more rows from a database table. It permanently
removes data from the table and should be used with caution. The basic syntax for a delete operation
in SQL is as follows:

```sql
DELETE FROM table_name
WHERE condition;
```

- `table_name`: The name of the table from which to delete rows.

- `WHERE condition`: Specifies the condition that determines which rows to delete. If omitted, all
rows in the table will be deleted.

Example of a delete operation:

 ```sql
DELETE FROM users
WHERE user_id = 123;
```

In this example, the user with `user_id` 123 is deleted from the `users` table.

15) explain Constructor and destructor in PHP with example.

16) Elaborate the following: i) ___call() ii) mysqli_connect()

Certainly! Let's elaborate on the `__call()` magic method and the `mysqli_connect()` function:

i) **`__call()` Magic Method**:

In PHP, `__call()` is a magic method that is automatically invoked when an inaccessible or undefined
method is called on an object. It allows you to intercept calls to undefined methods and handle them
dynamically.

The syntax for `__call()` method is:

```php
public function __call(string $name, array $arguments): mixed
```
- `$name`: The name of the method that was called.
- `$arguments`: An array containing the arguments passed to the method.

You can define `__call()` in a class to provide custom behavior when a specific method is not defined
within the class.

Example of using `__call()` method:

```php
class MyClass {
public function __call(string $name, array $arguments) {
echo "Calling undefined method: $name";
// Additional custom logic can be added here
}
}

$obj = new MyClass();

$obj->undefinedMethod(); // Output: Calling undefined method: undefinedMethod
```

In this example, when the `undefinedMethod()` is called on the `$obj` object, since it is not defined
in the `MyClass` class, the `__call()` magic method is invoked, and the custom message is echoed.
ii) **`mysqli_connect()` Function**:
The `mysqli_connect()` function is used in PHP to establish a connection to a MySQL database using
the MySQL Improved Extension (MySQLi). It creates a connection object that can be used to perform
database operations such as executing queries, retrieving results, and managing transactions.

The basic syntax for `mysqli_connect()` is:

```php
mysqli_connect(string $host, string $username, string $password, string $database, int $port = 3306,
string $socket = '')
```
- `$host`: The hostname or IP address of the MySQL server.
- `$username`: The username used to connect to the MySQL server.
- `$password`: The password used to connect to the MySQL server.
- `$database`: The name of the database to connect to.
- `$port`: Optional. The port number where MySQL server is running. Default is `3306`.
- `$socket`: Optional. The path to the socket used for local MySQL connections.

Example of using `mysqli_connect()` to establish a database connection:

```php
$host = 'localhost';
$username = 'username';
$password = 'password';
$database = 'my_database';

$conn = mysqli_connect($host, $username, $password, $database);

if (!$conn) {
die('Connection failed: ' . mysqli_connect_error());
} else {
echo 'Connected successfully!';
}
```

In this example, `mysqli_connect()` is used to connect to the MySQL server running on 'localhost'
using the provided username, password, and database name. If the connection is successful, it prints
'Connected successfully!'; otherwise, it prints the error message obtained from
`mysqli_connect_error()`.
17. Define Introspection and explain it with suitable example.