> For the complete documentation index, see [llms.txt](https://docs.cmsfullform.com/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.cmsfullform.com/documents/models.md).

# Models

Models in PHPFast handle database interactions, including querying, inserting, updating, and deleting records. To simplify these operations, PHPFast offers a `BaseModel`, which your models can extend to leverage built-in database functionalities efficiently.

In this section, we will explore the `BaseModel` class, which serves as the foundation for database operations in the PHPFast framework. It provides essential methods for interacting with the database, including querying, inserting, updating, and deleting records, making it easier for other models to manage data efficiently.

## Create Models via Command

This command creates a new model file in the `application/Models` directory.

* The generated model includes a default template with the `_schema()` method.
* It helps define the database table’s structure and provides basic CRUD (Create, Read, Update, Delete) functions.

**Command:**

```sh
php init Models <model_name>

// Example: php init models Users
```

This creates `UsersModel.php` inside `application/Model/`.

## Accessing Model

```php
<?php
use App\Models\UsersModel;

$usersModel = new UsersModel();
```

## Configuration

To switch between database drivers, update the `db_driver` setting in `application/Config/Config.php`

```php
'db' => [
    'db_driver'   => 'mysql',
    'db_host'     => 'localhost',
    'db_port'     => 3306,
    'db_username' => 'root',
    'db_password' => '',
    'db_database' => 'cms.vn',
    'db_charset'  => 'utf8mb4',
    'db_collate'  => 'utf8mb4_unicode_ci',
],
```

## **Example Usage**

```php
<?php
namespace App\Models;
use System\Core\BaseModel;

class UsersModel extends BaseModel {
    protected $table = 'users';
    protected $fillable = ['username', 'email', 'password', 'fullname'];
    protected $guarded = ['id', 'created_at', 'updated_at'];
    
    protected function _schema()
    {
        return [
            'id'           => 'int',
            'username'     => 'string',
            'email'        => 'string',
            'created_at'   => 'timestamp',
            ...            => interface
        ];
    }
    
    protected function _table() {
        return 'users'; // Defines that this model works with the 'users' table
    }
    
    public function getUsers($where = '', $params = [], $orderBy = 'id DESC', $limit = null, $offset = null) {
        return $this->list($this->table, $where, $params, $orderBy, $limit, $offset);
    }
    

    public function getUserById($id){
        return $this->row($this->table, 'id = ?', [$id]);
    }
    
    public function getUsersPage($where = '', $params = [], $orderBy = 'id DESC', $page = 1, $limit = null) {
        return $this->listpaging($this->table, $where, $params, $orderBy, $page, $limit);
    }
    
    public function addUser($data) {
        $data = $this->fill($data);
        return $this->add($this->table, $data);
    }
    
    public function updateUser($id, $data) {
        $data = $this->fill($data);
        return $this->set($this->table, $data, 'id = ?', [$id]);
    }
    
    public function deleteUser($id) {
        return $this->del($this->table, 'id = ?', [$id]);
    }
}
```

**List of Common Methods in a Model (Example in UsersModel):**

#### **Model Configuration and Schema**

* `_schema()`: Defines the database schema for the `users` table, specifying columns, data types, and constraints.

#### **Retrieving User Data**

* `getUsers()`: Retrieves a list of all users from the `users` table, with optional filtering conditions.
* `getUsersPage($where, $params, $orderBy, $page, $limit)`: Retrieves a paginated list of users.
* `getFieldUsersPage($fields, $where, $params, $orderBy, $page, $limit)`: Retrieves a paginated list of users but only fetches specific fields.
* `getUserById($id)`: Retrieves detailed user information based on `ID`.
* `getUserByIdField($fields, $id)`: Retrieves specific fields of a user based on `ID`.
* `getUserByUsername($username)`: Finds a user based on `username`.
* `getUserByEmail($email)`: Finds a user based on `email`.

#### **Managing User Data (Add, Update, Delete)**

* `addUser($data)`: Adds a new user to the `users` table.
* `updateUser($id, $data)`: Updates user information based on `ID`.
* `deleteUser($id)`: Deletes a user from the system based on `ID`.

**Advanced Functions**

* `searchUser($conditions)`: Searches for users based on different criteria using flexible conditions.
* `getLocation($userId)`: Retrieves the geographical location (`longitude`, `latitude`) of a user based on their `ID`, if valid location data exists.

## Model in Controller

```php
<?php
namespace App\Controllers;

use System\Core\BaseController;
use App\Models\UsersModel;

class UsersController extends BaseController
{
    protected $usersModel;

    public function __construct() {
        $this->usersModel = new UsersModel();
    }

    public function index() {
        $users = $this->usersModel->getUsers();
        $this->render('users/index', ['users' => $users]);
    }
    
    public function profile() {
        $id = S_GET('id') ?? ''; 
        $userInfo = $this->usersModel->getUserById($id);
        $this->render('users/profile', ['info' => $userInfo]);
    }
}
```

{% hint style="warning" %}
Important

To create a model, extend the [`BaseModel`](/documents/core/basemodel.md) class and define the `$table`, `$fillable`, and `$guarded` properties as needed. Override any methods as required to meet the specific needs of the model.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

```
GET https://docs.cmsfullform.com/documents/models.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.