PHP CodeIgniter - Basic CRUD operation with MySQL Database with example

If you're starting web development using PHP, one of the first concepts you'll learn is CRUD Operations. Every dynamic application—from student management systems to eCommerce websites—depends on CRUD functionality.

Using CodeIgniter, developers can build CRUD applications much faster while keeping the code organized and secure. CodeIgniter follows the MVC (Model-View-Controller) architecture, making development simple even for beginners.

In this guide, you'll learn PHP CodeIgniter Basic CRUD Operation with MySQL Database, understand how each component works, and build a simple employee management application step by step.

 

What is CRUD in PHP CodeIgniter?

CRUD stands for:

• C – Create

• R – Read

• U – Update

• D – Delete

These four operations allow users to interact with database records.

For example:

• Add a new employee

• View employee details

• Edit employee information

• Delete employee records

Almost every web application uses CRUD functionality.

 

Why Use CodeIgniter for CRUD Operations?

CodeIgniter is one of the most popular PHP frameworks because it is lightweight, fast, and easy to learn.

Benefits include:

• Simple MVC architecture

• Excellent database support

• Built-in security features

• Fast performance

• Easy routing

• Reusable code

• Less configuration

• Beginner-friendly

Whether you're creating a blog, CRM, ERP, school management software, or inventory system, CRUD is the foundation of every project.

 

Prerequisites

Before starting, install the following:

• PHP 8.x

• CodeIgniter

• MySQL

• Apache Server

• XAMPP or WAMP

• Visual Studio Code

• phpMyAdmin

 

Understanding MVC Architecture

CodeIgniter follows MVC.

Model

The Model communicates with the database.

Example:

• Insert records

• Update records

• Delete records

• Fetch records

 

View

The View displays data to users.

Examples:

• HTML pages

• Forms

• Tables

• Bootstrap UI

 

Controller

The Controller connects Models and Views.

It receives requests, processes data, and returns responses.

 

Database Structure

Create a database.

CREATE DATABASE employee_db;

Create a table.

CREATE TABLE employees (

 

id INT AUTO_INCREMENT PRIMARY KEY,

 

name VARCHAR(100),

 

email VARCHAR(100),

 

phone VARCHAR(20)

 

);

 

Project Structure

A simple CRUD project usually contains:

application/

 

controllers/

 

Employee.php

 

models/

 

Employee_model.php

 

views/

 

employee_list.php

 

employee_add.php

 

employee_edit.php

Each file has a specific responsibility, making the application easy to maintain.

 

Step 1: Configure Database

Open:

application/config/database.php

Example:

$db['default'] = array(

 

'hostname' => 'localhost',

 

'username' => 'root',

 

'password' => '',

 

'database' => 'employee_db',

 

'dbdriver' => 'mysqli'

 

);

Now CodeIgniter can communicate with MySQL.

 

Step 2: Create the Model

Models handle database queries.

Example:

class Employee_model extends CI_Model {

 

public function getEmployees()

 

{

 

return $this->db->get('employees')->result();

 

}

 

}

The Model keeps SQL queries separate from business logic.

 

Step 3: Create the Controller

Controllers process user requests.

Example:

class Employee extends CI_Controller {

 

public function index()

 

{

 

$data['employees']=$this->Employee_model->getEmployees();

 

$this->load->view('employee_list',$data);

 

}

 

}

The controller loads data and sends it to the view.

 

Step 4: Create the View

Views display information.

Example:

<table>

 

<tr>

 

<th>Name</th>

 

<th>Email</th>

 

</tr>

 

</table>

Views should contain presentation code only.

 

CRUD Operations Explained

Create Operation

The Create operation inserts new records.

Example:

Employee Name

Employee Email

Employee Phone

After clicking Submit, data is saved into MySQL.

Model:

public function insertEmployee($data)

 

{

 

$this->db->insert('employees',$data);

 

}

 

Read Operation

Read retrieves data from the database.

Example:

public function getEmployees()

 

{

 

return $this->db->get('employees')->result();

 

}

Output:

ID	Name	Email	Phone
1	John	john@gmail.com	9876543210
2	David	david@gmail.com	9999999999

 

Update Operation

Update edits existing records.

Example:

$this->db->where('id',$id);

 

$this->db->update('employees',$data);

Users can modify employee details without creating duplicate records.

 

Delete Operation

Delete removes records permanently.

Example:

$this->db->where('id',$id);

 

$this->db->delete('employees');

Usually, applications display a confirmation message before deletion.

 

Complete CRUD Workflow

The CRUD process follows this simple flow:

1. User opens the Employee page.

2. Employee list loads from MySQL.

3. User clicks Add Employee.

4. Form is submitted.

5. Data is validated.

6. Record is inserted.

7. Employee list refreshes.

8. User edits an employee.

9. Updated data is saved.

10. User deletes an employee if needed.

 

Input Validation

Never trust user input.

CodeIgniter provides validation rules.

Example:

$this->form_validation->set_rules('name','Name','required');

 

$this->form_validation->set_rules('email','Email','required|valid_email');

Validation prevents invalid data from entering your database.

 

Security Best Practices

When building CRUD applications:

• Validate every form.

• Escape user input.

• Enable CSRF protection.

• Use prepared database queries.

• Filter XSS attacks.

• Never expose database credentials.

• Limit user permissions.

• Keep CodeIgniter updated.

These practices improve both security and application reliability.

 

Advantages of Using CRUD in CodeIgniter

Using CodeIgniter for CRUD offers several advantages:

• Clean project structure

• Faster development

• Easy maintenance

• Better performance

• Built-in database library

• Secure query builder

• Reusable components

• Easy debugging

• Scalable architecture

 

Real-World Applications

CRUD operations are used in almost every business application, including:

• Student Management Systems

• Employee Management Software

• Hospital Management Systems

• CRM Software

• Inventory Management

• Hotel Booking Systems

• eCommerce Websites

• Food Ordering Platforms

• School ERP

• HR Management Systems

 

Common Errors During CRUD Development

Beginners often encounter these issues:

Database Connection Error

Check database credentials and server status.

Table Not Found

Verify the table name in your queries.

Undefined Variable

Ensure variables are passed correctly from the controller to the view.

Page Not Found (404)

Confirm routes and controller names.

Validation Errors

Make sure validation rules match your form fields.

 

Tips for Writing Better CodeIgniter CRUD Applications

• Follow MVC principles.

• Keep controllers lightweight.

• Place all database queries in models.

• Use meaningful variable names.

• Validate all user inputs.

• Reuse common functions.

• Separate business logic from presentation.

• Test every CRUD operation before deployment.

• Maintain proper folder organization.

• Document your code for future maintenance.

 

Conclusion

Learning PHP CodeIgniter Basic CRUD Operation with MySQL Database is one of the most important steps for every PHP developer. CRUD operations form the backbone of nearly every dynamic web application, from small business websites to enterprise-level software.

CodeIgniter simplifies database management with its MVC architecture, Query Builder, and built-in libraries, allowing developers to create secure, maintainable, and scalable applications efficiently. Once you understand how to create, read, update, and delete records, you'll be ready to build more advanced systems such as user authentication, inventory management, CRM platforms, school management systems, and eCommerce applications.

By following best practices like input validation, secure database handling, and clean code organization, you can develop reliable applications that are easier to maintain and scale over time.

In short, mastering CRUD operations in CodeIgniter provides a strong foundation for modern PHP web development and prepares you for building real-world applications with confidence.

 

FAQ

1. What is PHP CodeIgniter Basic CRUD Operation with MySQL Database?

It is the process of creating, reading, updating, and deleting records stored in a MySQL database using the CodeIgniter PHP framework. These four operations are the foundation of most dynamic web applications.

 

2. Why is CRUD important in CodeIgniter?

CRUD enables developers to manage database records efficiently. Almost every web application—including blogs, eCommerce stores, HR systems, and CRMs—depends on CRUD functionality for everyday operations.

 

3. Is CodeIgniter good for beginners?

Yes. CodeIgniter is lightweight, easy to learn, and follows the MVC architecture. Its clear structure, excellent documentation, and built-in tools make it an ideal framework for beginners learning PHP development.

 

4. What database is commonly used with CodeIgniter?

MySQL is the most commonly used database with CodeIgniter due to its speed, reliability, and compatibility. However, CodeIgniter also supports PostgreSQL, SQLite, SQL Server, and other database systems.

 

5. What are the four CRUD operations?

The four CRUD operations are:

• Create: Add new records.

• Read: Retrieve existing records.

• Update: Modify existing records.

• Delete: Remove records from the database.

 

6. How does MVC help in CRUD applications?

MVC separates the application into Models, Views, and Controllers. This improves code organization, simplifies maintenance, encourages code reuse, and makes the application easier to scale and test.

 

7. Can I perform CRUD without writing raw SQL queries?

Yes. CodeIgniter provides a Query Builder that lets you perform CRUD operations using PHP methods, reducing the need to write raw SQL while improving security and readability.

 

8. How can I secure my CRUD application?

You can secure your application by validating user input, enabling CSRF protection, escaping output to prevent XSS attacks, using prepared queries through CodeIgniter’s Query Builder, and keeping your framework updated.

 

9. What are common uses of CRUD operations?

CRUD operations are used in employee management systems, school portals, inventory software, healthcare applications, customer relationship management (CRM), hotel booking platforms, eCommerce websites, and many other database-driven applications.

 

10. Can CRUD applications be expanded with additional features?

Absolutely. Once the basic CRUD functionality is in place, you can extend your application with features such as user authentication, role-based access control, search, pagination, file uploads, REST APIs, reporting dashboards, and AJAX integration for a richer user experience.