Unit 4:

Filehandling- Working With Databases In Php- Sessions, Cookies, And Ftp

Filehandling in Php

File handling in PHP allows you to create, read, write, append, and delete files on a server. PHP
provides several built-in functions for file operations.

1. Opening a File
PHP uses the fopen() function to open files. The syntax is:

php
$file = fopen("filename.txt", "mode");

File Modes

Mode Description
r Read only. File must exist.
r+ Read/Write. File must exist.
w Write only. Creates a new file if it doesn't exist.
w+ Read/Write. Creates a new file if it doesn't exist.
a Append. Creates a new file if it doesn't exist.
a+ Read/Append. Creates a new file if it doesn't exist.

2. Reading a File
Using fread()

Reads a specific number of bytes from a file.

php

$file = fopen("example.txt", "r");

$content = fread($file, filesize("example.txt"));
fclose($file);
echo $content;

Using fgets()

Reads a file line by line.

php

$file = fopen("example.txt", "r");

while (!feof($file)) {
echo fgets($file) . "<br>";
}
fclose($file);

Using file_get_contents()

Reads the entire file into a string.

php

$content = file_get_contents("example.txt");
echo $content;

3. Writing to a File
Using fwrite()

Writes data to a file.

php

$file = fopen("example.txt", "w");

fwrite($file, "Hello, Sugarcane!");
fclose($file);

Using file_put_contents()

A simpler way to write to a file.

php

file_put_contents("example.txt", "Hello, PHP!");

4. Appending to a File
php

$file = fopen("example.txt", "a");

fwrite($file, "\nAppending this line.");
fclose($file);
5. Deleting a File
php

if (file_exists("example.txt")) {
unlink("example.txt");
echo "File deleted!";
} else {
echo "File does not exist!";
}

6. Checking if a File Exists

php

if (file_exists("example.txt")) {
echo "File exists!";
} else {
echo "File does not exist!";
}

7. Getting File Information

php

echo "File size: " . filesize("example.txt") . " bytes";

echo "File type: " . filetype("example.txt");

Working with Databases in Php

Working with databases in PHP involves connecting to a database, performing queries, retrieving
data, and handling results. MySQL is one of the most commonly used databases with PHP, and
we'll focus on that in this guide. You can interact with a MySQL database using two main
methods: MySQLi (MySQL Improved) and PDO (PHP Data Objects). Here's an overview of
both approaches:

1. MySQLi (MySQL Improved)

MySQLi supports both procedural and object-oriented programming styles. Below are the basic
operations using MySQLi.
Connecting to MySQL Database
 Syntax:

php

// Procedural style
$conn = mysqli_connect($servername, $username, $password, $dbname);

// Object-oriented style
$conn = new mysqli($servername, $username, $password, $dbname);

 Example:

php

// Procedural Style
$servername = "localhost";
$username = "root";
$password = "";
$dbname = "test_db";

// Create connection
$conn = mysqli_connect($servername, $username, $password, $dbname);

// Check connection
if (!$conn) {
die("Connection failed: " . mysqli_connect_error());
}
echo "Connected successfully";

Note: You should always check whether the connection is successful using
mysqli_connect_error().

2. Performing Queries with MySQLi

SELECT Query (Retrieving data)

 Syntax:

php

$result = mysqli_query($conn, $query);

 Example (Selecting all rows from a table):

php
 $sql = "SELECT id, name FROM users";
$result = mysqli_query($conn, $sql);

if (mysqli_num_rows($result) > 0) {
// Output data for each row
while($row = mysqli_fetch_assoc($result)) {
echo "id: " . $row["id"]. " - Name: " . $row["name"]. "<br>";
}
} else {
echo "0 results";
}
INSERT Query (Inserting data)

 Syntax:

php

$sql = "INSERT INTO tablename (column1, column2, ...) VALUES (value1, value2, ...)";

 Example (Inserting data):

php

$sql = "INSERT INTO users (name, email) VALUES ('John Doe', '[email protected]')";

if (mysqli_query($conn, $sql)) {
echo "New record created successfully";
} else {
echo "Error: " . $sql . "<br>" . mysqli_error($conn);
}
UPDATE Query (Updating data)

 Syntax:

php

$sql = "UPDATE tablename SET column1=value1, column2=value2 WHERE condition";

 Example (Updating data):

php

$sql = "UPDATE users SET email='[email protected]' WHERE id=1";

if (mysqli_query($conn, $sql)) {
echo "Record updated successfully";
} else {
echo "Error: " . $sql . "<br>" . mysqli_error($conn);
}
DELETE Query (Deleting data)

 Syntax:

php

$sql = "DELETE FROM tablename WHERE condition";

 Example (Deleting data):

php

$sql = "DELETE FROM users WHERE id=1";

if (mysqli_query($conn, $sql)) {
echo "Record deleted successfully";
} else {
echo "Error: " . $sql . "<br>" . mysqli_error($conn);
}

3. Closing the Database Connection

Always close the connection once you're done with database operations:

 Syntax:

php

mysqli_close($conn);

 Example:

php

mysqli_close($conn);

4. PDO (PHP Data Objects)

PDO is a more flexible and secure way to interact with databases, supporting various database
types, including MySQL, PostgreSQL, SQLite, and others. Here's how to use it with MySQL.

Connecting to MySQL Database using PDO

 Syntax:

php
 try {
$conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
echo "Connected successfully";
} catch(PDOException $e) {
echo "Connection failed: " . $e->getMessage();
}

 Example:

php

$servername = "localhost";
$username = "root";
$password = "";
$dbname = "test_db";

try {
$conn = new PDO("mysql:host=$servername;dbname=$dbname", $username, $password);
$conn->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
echo "Connected successfully";
} catch(PDOException $e) {
echo "Connection failed: " . $e->getMessage();
}

Note: The PDO::ATTR_ERRMODE attribute helps to handle errors by throwing exceptions.

5. Performing Queries with PDO

SELECT Query (Retrieving data)

 Syntax:

php

$stmt = $conn->query($query);
$rows = $stmt->fetchAll();

 Example (Selecting data):

php

$stmt = $conn->query("SELECT id, name FROM users");

while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
echo "id: " . $row["id"]. " - Name: " . $row["name"]. "<br>";
}
INSERT, UPDATE, DELETE Queries (Manipulating data)

To perform INSERT, UPDATE, or DELETE, you can use prepared statements:

  Example (Prepared Statements):

INSERT Query:

php

$stmt = $conn->prepare("INSERT INTO users (name, email) VALUES (:name, :email)");

$stmt->bindParam(':name', $name);
$stmt->bindParam(':email', $email);

// Insert data
$name = "John Doe";
$email = "[email protected]";
$stmt->execute();

UPDATE Query:

php

$stmt = $conn->prepare("UPDATE users SET email = :email WHERE id = :id");

$stmt->bindParam(':email', $email);
$stmt->bindParam(':id', $id);

// Update data
$email = "[email protected]";
$id = 1;
$stmt->execute();

DELETE Query:

php

$stmt = $conn->prepare("DELETE FROM users WHERE id = :id");

$stmt->bindParam(':id', $id);

// Delete data
$id = 1;
$stmt->execute();

6. Closing the Database Connection

In PDO, the connection is automatically closed when the object is destroyed, but you can
explicitly set it to null to disconnect:

 Syntax:

php

$conn = null;
  Example:

php

$conn = null; // Close connection

Session in PHP

A session in PHP is a way to store user-specific information on the server to maintain state
across multiple page requests. Unlike cookies, which store data on the client's browser, sessions
store data on the server, making it more secure. Here's how sessions work:

1. Starting a Session: A session is started using the session_start() function. This should be
called at the beginning of each page that requires session data.

php

session_start();

2. Storing Session Data: Data is stored in the $_SESSION superglobal array. You can set
session variables like this:

php

$_SESSION['username'] = 'JohnDoe';

3. Accessing Session Data: You can retrieve session data on any page by accessing the
$_SESSION array.

php

echo $_SESSION['username']; // Output: JohnDoe

4. Modifying and Removing Session Variables: You can modify or remove session
variables. To remove a session variable, use unset():

php

unset($_SESSION['username']);

5. Ending a Session: To destroy a session and remove all session data, use session_destroy()
along with session_unset():

php

session_unset();
session_destroy();
Sessions are essential for maintaining user authentication and preferences across pages. They
provide a secure way to handle sensitive information, as session data is stored on the server
rather than the client side.

Cookies in PHP

A cookie in PHP is a small piece of data sent from the server and stored on the user's browser.
Cookies allow you to store user preferences, authentication information, and other details that
persist across page reloads and sessions. Here’s how cookies work in PHP:

1. Setting a Cookie: Cookies are set using the setcookie() function. You need to set cookies
before any output is sent to the browser (e.g., no HTML or echo statements before calling
setcookie()).
o Syntax:

php

setcookie('name', 'value', time() + 3600, '/');

This sets a cookie named name with a value of value that expires in one hour.

2. Cookie Parameters: The setcookie() function has the following parameters:

o name: The name of the cookie.
o value: The value stored in the cookie.
o expiration: The time the cookie will expire. Use time() function to set the
expiration time.
o path: The path on the server where the cookie will be available ("/" means it's
available throughout the site).
3. Accessing Cookie Data: Cookies are accessible through the $_COOKIE superglobal array.
o Syntax:

php

echo $_COOKIE['name'];

This retrieves the value of the cookie named name.

4. Modifying a Cookie: You can modify a cookie by setting it again with a new value and
the same expiration time.
o Example:

php

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

 5. Deleting a Cookie: To delete a cookie, you must set its expiration time to a past time.
o Syntax:

php

setcookie('name', '', time() - 3600, '/');

Cookies are useful for persistent user preferences and session data, but they have limitations,
such as size constraints (typically 4KB). They also pose security risks since users can manually
modify cookie data, so sensitive information should be avoided in cookies.

FTP in PHP

FTP (File Transfer Protocol) in PHP allows you to transfer files between a client and a server
over the Internet. PHP provides built-in functions to interact with an FTP server, such as
connecting, uploading, downloading, and managing files. Here's a brief overview of working
with FTP in PHP:

1. Connecting to an FTP Server: You can establish a connection to an FTP server using
the ftp_connect() function.
o Syntax:

php

$conn_id = ftp_connect('ftp.example.com');

o Example:

php

$conn_id = ftp_connect('ftp.example.com');
if (!$conn_id) {
die("Could not connect to FTP server.");
}

2. Logging in to an FTP Server: After connecting, you need to log in using the ftp_login()
function by providing a username and password.
o Syntax:

php

$login_result = ftp_login($conn_id, 'username', 'password');

o Example:

php

$login_result = ftp_login($conn_id, 'myusername', 'mypassword');

if (!$login_result) {
 die("Could not log in to FTP server.");
}

3. Uploading a File to the FTP Server: You can upload files from your local machine to
the FTP server using ftp_put().
o Syntax:

php

ftp_put($conn_id, 'remote_file.txt', 'local_file.txt', FTP_ASCII);

o Example:

php

ftp_put($conn_id, 'remote_file.txt', 'local_file.txt', FTP_BINARY);

4. Downloading a File from the FTP Server: To download a file from the FTP server, you
use ftp_get().
o Syntax:

php

ftp_get($conn_id, 'local_file.txt', 'remote_file.txt', FTP_BINARY);

o Example:

php

ftp_get($conn_id, 'local_file.txt', 'remote_file.txt', FTP_BINARY);

5. Closing the FTP Connection: Once the FTP operations are complete, it is important to
close the connection using ftp_close().
o Syntax:

php

ftp_close($conn_id);

o Example:

php

ftp_close($conn_id);

Additional FTP Functions:

 Checking if a File Exists on the FTP Server: ftp_size()

 Changing Directories: ftp_chdir()
  Listing Files: ftp_nlist()

Unit 5: Ajax – Advanced Ajax – drawing images on the server

What is AJAX?
AJAX stands for asynchronous Javascript and XML. AJAX is not a programming language or
technology, but it is a combination of multiple web-related technologies like HTML, XHTML, CSS,
JavaScript, DOM, XML, XSLT and XMLHttpRequest object. The AJAX model allows web developers
to create web applications that are able to dynamically interact with the user. It will also be able to
quickly make a background call to web servers to retrieve the required application data. Then update the
small portion of the web page without refreshing the whole web page.
AJAX = Asynchronous JavaScript And XML.

AJAX is not a programming language.

AJAX just uses a combination of:

A browser built-in XMLHttpRequest object (to request data from a web server)
JavaScript and HTML DOM (to display or use the data)
Working of AJAX
Traditional web applications are created by adding loosely web pages through links in a predefined order.
Where the user can move from one page to another page to interact with the different portions of the
applications. Also, HTTP requests are used to submit the web server in response to the user action. After
receiving the request the web server fulfills the request by returning a new webpage which, then displays
on the web browser. This process includes lots of pages refreshing and waiting.
AJAX change this whole working model by sharing the minimum amount of data between the web
browser and server asynchronously.
It provides a desktop-like feel by passing the data on the web pages or by allowing the data to be
displayed inside the existing web application. It will replace loosely integrated web pages with tightly
integrated web pages. AJAX application uses the resources very well. It creates an additional layer known
as AJAX engine in between the web application and web server due to which we can make background
server calls using JavaScript and retrieve the required data, can update the requested portion of a web
page without casing full reload of the page. It reduces the page refresh timing and provides a fast and
responsive experience to the user. Asynchronous processes reduce the workload of the web server by
dividing the work with the client computer. Due to the reduced workload web servers become more
responsive and fast.

Advantages of AJAX
The following are the advantages of AJAX −
 It creates responsive and interactive web applications.
 It supports the development of patterns and frameworks that decrease the development time.
 It makes the best use of existing technology and feature instead of using some new technology.
 It makes an asynchronous call to the web server which means the client doesn't have to wait for
the data to arrive before starting rendering.
Disadvantages of AJAX
The following are the disadvantages of AJAX −
 AJAX is fully dependent on JavaScript. So if anything happens with JavaScript in the browser
AJAX will not support.
 The debugging of AJAX applications is difficult.
 Bookmarking of AJAX-enabled pages required pre-planning.
 If one request can fail, then it can fail the load of the whole webpage.
 If JavaScript is disabled in your web browser, then you are not able to run the AJAX webpage.

What is advanced AJAX?

The Advanced AJAX course is designed to demonstrate how to build web pages that use AJAX to create
interactivity with data on a server. The course begins with an exploration of the XHR (XMLHttpRequest)
Object. Next, it then moves on to investigate common design principles around AJAX and its security.

Advanced AJAX (10 Mark Answer)

AJAX (Asynchronous JavaScript and XML) is a technique used to create dynamic and
interactive web applications. It allows web pages to retrieve data from the server asynchronously
without refreshing the entire page, which results in a more fluid and responsive user experience.
Advanced AJAX takes this concept further by enhancing the interaction with servers and
handling complex data in various formats such as JSON, XML, HTML, or plain text.

Here's a detailed explanation of advanced AJAX concepts:

1. Basic AJAX Workflow

AJAX operates by sending an asynchronous request to the server using JavaScript, then
processing the server's response in the browser without reloading the page. The process typically
follows these steps:

1. User Action: A user triggers an event (e.g., button click or form submission).
2. AJAX Request: JavaScript sends a request to the server (via XMLHttpRequest or the newer fetch()
API).
3. Server Processing: The server processes the request and returns a response.
4. Display Response: JavaScript receives the server response and updates the web page
dynamically.

2. Using XMLHttpRequest (Traditional AJAX)

The traditional way of using AJAX is through the XMLHttpRequest object, which sends and
receives data to/from the server.

 Creating an XMLHttpRequest Object:

javascript

var xhr = new XMLHttpRequest();

 Sending a GET request:

javascript

xhr.open("GET", "data.php", true);

 xhr.onreadystatechange = function () {
if (xhr.readyState == 4 && xhr.status == 200) {
document.getElementById("result").innerHTML = xhr.responseText;
}
};
xhr.send();

In the example above, a request is made to data.php, and the result is displayed in the HTML
element with the id result.

3. Using fetch() (Modern AJAX)

The fetch() API is a modern approach that provides a more powerful and flexible way to make
HTTP requests, and it returns promises. It’s easier to work with and has a simpler syntax than
XMLHttpRequest.

 Syntax:

javascript

fetch('data.php')
.then(response => response.text())
.then(data => document.getElementById("result").innerHTML = data)
.catch(error => console.error('Error:', error));

 Sending Data with fetch():

javascript

fetch('data.php', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({ key: 'value' }),
})
.then(response => response.json())
.then(data => console.log(data));

4. Sending JSON Data

AJAX allows sending and receiving JSON data, which is a lightweight and commonly used data
format. Using JSON simplifies handling complex data structures like arrays and objects.

 Sending JSON Data (using fetch()):

javascript
 fetch('server.php', {
method: 'POST',
headers: {
'Content-Type': 'application/json',
},
body: JSON.stringify({
username: 'john_doe',
email: '[email protected]'
})
})
.then(response => response.json())
.then(data => console.log(data));

 Receiving JSON Data:

javascript

fetch('server.php')
.then(response => response.json())
.then(data => {
console.log(data); // Process the JSON response
});

5. Asynchronous vs. Synchronous Requests

AJAX allows asynchronous requests, which means that the browser can continue with other
tasks while waiting for a server response. However, you can also make synchronous requests
(though it is discouraged, as it can block the UI).

 Asynchronous Request (default):

javascript

xhr.open('GET', 'data.php', true); // Third parameter `true` makes it async

 Synchronous Request (not recommended):

javascript

xhr.open('GET', 'data.php', false); // Third parameter `false` makes it sync

6. Handling Errors and Timeouts

In advanced AJAX, it’s essential to handle errors (e.g., network issues, server errors) and
timeouts gracefully.

 Handling Errors:
 javascript

xhr.onerror = function() {
console.error("Request failed");
};

 Timeout Handling:

javascript

xhr.timeout = 5000; // 5 seconds timeout

xhr.ontimeout = function() {
console.error("Request timed out");
};

7. Cross-Origin Resource Sharing (CORS)

In modern web development, AJAX requests from one domain to another domain (cross-origin
requests) often require special handling due to security restrictions. The server must explicitly
allow cross-origin requests using HTTP headers like Access-Control-Allow-Origin.

 Example of a CORS header:

php

header("Access-Control-Allow-Origin: *");

8. JSONP (JSON with Padding)

For older browsers or situations where CORS is not supported, JSONP is a technique that allows
you to make cross-origin requests by exploiting the <script> tag's ability to bypass the same-origin
policy.

 Using JSONP:

javascript

function handleResponse(data) {
console.log(data);
}
var script = document.createElement('script');
script.src = 'http://example.com/data.php?callback=handleResponse';
document.body.appendChild(script);

9. AJAX with jQuery

While XMLHttpRequest and fetch() are widely used, jQuery simplifies AJAX with a consistent
syntax for handling browser differences and asynchronous operations.

 Using jQuery’s $.ajax():

javascript

$.ajax({
url: 'data.php',
type: 'GET',
success: function(response) {
$('#result').html(response);
},
error: function(xhr, status, error) {
console.error('AJAX Error: ' + error);
}
});

 Using jQuery’s $.get() and $.post():

javascript

$.get('data.php', function(response) {
$('#result').html(response);
});

10. Real-World Use Cases of AJAX

 Form Validation: AJAX allows real-time form validation by sending form data to the server
without reloading the page.
 Live Search: As users type in a search box, AJAX sends a request to the server and returns
search results in real time.
 Infinite Scrolling: As the user scrolls down a page, AJAX requests more data from the server
and appends it to the page.
 Chat Applications: Real-time communication, where messages are sent and received without
refreshing the page.

Drawing Images on the Server Using AJAX (10 Mark Answer)

In modern web applications, drawing images on the server using GD Library (Graphics Draw) AJAX is
a common requirement, especially when you need to generate dynamic images such as charts, graphs, or
custom drawings without reloading the page. AJAX allows the client to communicate with the server
asynchronously to request a new image, and then render the image dynamically on the client-side.
Here’s how you can create and send dynamic images from the server using AJAX:

1. Concept Overview
 1. AJAX Request: The client sends an AJAX request to the server, asking for an image (e.g., a
dynamically drawn chart or a generated image).
2. Server-side Image Creation: On the server (using PHP and GD Library), the server generates
the image based on the data received in the request.
3. AJAX Response: The server returns the image (as binary or an image URL) as the response.
4. Displaying the Image on Client: The client (browser) receives the image and displays it without
reloading the page.

2. PHP Server-Side Image Drawing

Let's first see how we can create an image on the server using PHP.
 Step 1: The server-side PHP script will generate an image using the GD library.
Here’s an example of generating an image dynamically on the server:
php

<?php
// draw_image.php

// Create a blank image

$image = imagecreatetruecolor(400, 300);

// Allocate colors
$background_color = imagecolorallocate($image, 255, 255, 255); // White
$text_color = imagecolorallocate($image, 0, 0, 0); // Black

// Fill the background with white color

imagefill($image, 0, 0, $background_color);

// Add some text

$text = "Dynamic Image with AJAX!";
imagettftext($image, 20, 0, 50, 150, $text_color, './arial.ttf', $text); // Change font path as needed
// Set header for PNG output
header('Content-Type: image/png');

// Output the image to the browser

imagepng($image);

// Free memory
imagedestroy($image);
?>
In this example:
 A 400x300 image is created.
 The background is filled with white color.
 The text "Dynamic Image with AJAX!" is drawn in black color.

3. AJAX Request to the Server

Now, we will create an AJAX request using JavaScript (or jQuery) that sends the request to the server
to generate and display the image.
 Step 2: The AJAX request will send the request to draw_image.php and display the image in an
HTML img element.
AJAX Request Using jQuery
html

<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Dynamic Image Drawing with AJAX</title>
<script src="https://code.jquery.com/jquery-3.6.0.min.js"></script>
<script>
function loadImage() {
 // Send AJAX request to the server
$.ajax({
url: 'draw_image.php', // The PHP script that generates the image
type: 'GET',
success: function(data) {
// Append the image to the img element (using a data URI or image src)
$('#image-container').html('<img src="data:image/png;base64,' + data + '" />');
},
error: function() {
alert('Error loading image');
}
});
}
</script>
</head>
<body>
<h2>Click the button to generate a dynamic image using AJAX</h2>
<button onclick="loadImage()">Generate Image</button>
<div id="image-container">
<!-- Image will be displayed here -->
</div>
</body>
</html>

4. Explanation of the Process

1. Client-Side (AJAX):
o When the button is clicked, the loadImage() function is invoked.

o The $.ajax() function sends an HTTP GET request to the draw_image.php file.

o Upon successful completion, the server returns the image as a response, and we append it
to the #image-container element.
 2. Server-Side (PHP):
o The PHP script draw_image.php generates an image using the GD library.

o The image is sent as a PNG to the browser in response to the AJAX request.

5. Advanced Considerations
 Passing Data to Draw Dynamic Images:
o You can pass data through the AJAX request (e.g., chart data or user input) and use it to
create dynamic content. For example, you can send an array of numbers to the server and
draw a bar chart based on that data.
javascript
$.ajax({
url: 'draw_image.php',
type: 'POST',
data: {
chartData: [10, 20, 30, 40, 50] },
success: function(data)
{
$('#image-container').html('<img src="data:image/png;base64,' + data + '" />');
} });
On the server side, you can retrieve the data with $_POST['chartData'] and use it to draw a chart
dynamically.
 Error Handling:

Always handle errors in the AJAX request. This includes checking if the server
responded correctly, and managing the situation where the server fails to generate the
image.
 Caching:

If your image generation is expensive (i.e., it takes a lot of server resources), you
might want to cache the image on the server, and then send the URL to the client
instead of generating the image each time.
 Image Format:

You can change the image format by using different functions like imagejpeg() for
JPEG or imagegif() for GIFs, depending on the type of image you want to generate.