Aggrid Php Example Updated

AG Grid’s server-side row model requires specific request parameters. We’ll build a RESTful endpoint that handles:

File: db.php (PDO connection)

<?php
header('Content-Type: application/json');
header('Access-Control-Allow-Origin: *');
header('Access-Control-Allow-Methods: GET, POST, PUT, DELETE');
header('Access-Control-Allow-Headers: Content-Type');
$host = 'localhost';
$dbname = 'aggrid_demo';
$user = 'root';
$pass = '';
try 
$pdo = new PDO("mysql:host=$host;dbname=$dbname;charset=utf8mb4", $user, $pass);
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
 catch(PDOException $e) 
die(json_encode(['error' => 'Database connection failed']));
?>

File: server.php (main API logic)

<?php
require_once 'db.php';
$request_method = $_SERVER['REQUEST_METHOD'];
$input = json_decode(file_get_contents('php://input'), true);
// Handle GET request for grid data
if ($request_method === 'GET' && isset($_GET['action']) && $_GET['action'] === 'getRows') 
// Extract AG Grid request parameters
$startRow = isset($_GET['startRow']) ? (int)$_GET['startRow'] : 0;
$endRow = isset($_GET['endRow']) ? (int)$_GET['endRow'] : 100;
$limit = $endRow - $startRow;
$sortModel = isset($_GET['sortModel']) ? json_decode($_GET['sortModel'], true) : [];
$filterModel = isset($_GET['filterModel']) ? json_decode($_GET['filterModel'], true) : [];
// Base query
$sql = "SELECT * FROM products";
$countSql = "SELECT COUNT(*) as total FROM products";
$params = [];
// Build WHERE clause from filterModel
$whereClauses = [];
if (!empty($filterModel)) 
    foreach ($filterModel as $field => $filter) 
        if ($filter['filterType'] === 'text') 
            $whereClauses[] = "$field LIKE :$field";
            $params[":$field"] = '%' . $filter['filter'] . '%';
         elseif ($filter['filterType'] === 'number') 
            if (isset($filter['filter'])) 
                $whereClauses[] = "$field = :$field_eq";
                $params[":$field_eq"] = $filter['filter'];
if (isset($filter['filterTo'])) 
                $whereClauses[] = "$field <= :$field_to";
                $params[":$field_to"] = $filter['filterTo'];
if (!empty($whereClauses)) 
    $whereStr = " WHERE " . implode(" AND ", $whereClauses);
    $sql .= $whereStr;
    $countSql .= $whereStr;
// Build ORDER BY from sortModel
if (!empty($sortModel)) 
    $orderBy = [];
    foreach ($sortModel as $sort) 
        $orderBy[] = "$sort['colId'] $sort['sort']";
$sql .= " ORDER BY " . implode(", ", $orderBy);
// Add LIMIT for pagination
$sql .= " LIMIT $startRow, $limit";
// Get total row count (without pagination)
$totalStmt = $pdo->prepare($countSql);
foreach ($params as $key => &$val) 
    $totalStmt->bindParam($key, $val);
$totalStmt->execute();
$totalRows = $totalStmt->fetch(PDO::FETCH_ASSOC)['total'];
// Get paginated data
$stmt = $pdo->prepare($sql);
foreach ($params as $key => &$val) 
    $stmt->bindParam($key, $val);
$stmt->execute();
$rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
// Return AG Grid expected format
echo json_encode([
    'success' => true,
    'rows' => $rows,
    'lastRow' => $totalRows
]);
exit;


// Handle POST to add a new row
if ($request_method === 'POST' && isset($_GET['action']) && $_GET['action'] === 'addRow') 
$stmt = $pdo->prepare("INSERT INTO products (name, category, price, stock) VALUES (:name, :category, :price, :stock)");
$stmt->execute([
':name' => $input['name'],
':category' => $input['category'],
':price' => $input['price'],
':stock' => $input['stock']
]);
echo json_encode(['success' => true, 'id' => $pdo->lastInsertId()]);
exit;

// Handle PUT to update a row
if ($request_method === 'PUT' && isset($_GET['action']) && $_GET['action'] === 'updateRow') 
$stmt = $pdo->prepare("UPDATE products SET name=:name, category=:category, price=:price, stock=:stock WHERE id=:id");
$stmt->execute([
':id' => $input['id'],
':name' => $input['name'],
':category' => $input['category'],
':price' => $input['price'],
':stock' => $input['stock']
]);
echo json_encode(['success' => true]);
exit;

// Handle DELETE
if ($request_method === 'DELETE' && isset($_GET['action']) && $_GET['action'] === 'deleteRow') 
$id = $_GET['id'];
$stmt = $pdo->prepare("DELETE FROM products WHERE id = ?");
$stmt->execute([$id]);
echo json_encode(['success' => true]);
exit;
?>

[AG Grid (React/Vanilla JS)]
         │
         │ (HTTP POST with filter models)
         ▼
    [PHP API Endpoint – api/rows.php]
         │
         │ (Dynamic SQL with LIMIT, OFFSET)
         ▼
      [MySQL / PostgreSQL]
         │
         │ (Filtered, sorted, paginated data)
         ▼
         └──► JSON response back to AG Grid

AG Grid sends a payload like:

  "startRow": 0,
  "endRow": 100,
  "sortModel": ["colId":"name", "sort":"asc"],
  "filterModel": "age": "filterType":"number", "type":"greaterThan", "filter":21

Your PHP script must parse this and return:

  "rows": [...],
  "lastRow": 1542

Create a MySQL database and add a table with some sample data. For this example, we'll use a simple table called "employees" with the following columns:

| id | name | email | department | | --- | --- | --- | --- | | 1 | John Smith | john.smith@example.com | Sales | | 2 | Jane Doe | jane.doe@example.com | Marketing| | 3 | Bob Brown | bob.brown@example.com | IT |

This updated AG Grid PHP example provides a fully functional, enterprise-ready data grid with server-side sorting, filtering, pagination, and CRUD operations. The backend uses modern PHP (8.1+) with PDO, and the frontend leverages AG Grid v31’s server-side row model for optimal performance even with thousands of rows.

Next steps: Integrate AG Grid Enterprise features like Excel export, charting, or master/detail views, and enhance PHP with input validation, logging, and rate limiting for production deployment.

File structure recap:

aggrid-php-example/
├── index.html
├── server.php
├── db.php
└── (optional) .env for credentials

Run with php -S localhost:8000 and open http://localhost:8000. Your AG Grid will communicate seamlessly with the PHP backend, handling all dynamic data operations in real time.

Integrating AG Grid with PHP is a powerful way to handle large datasets with a modern, high-performance UI. Because PHP is a server-side language and AG Grid is a client-side JavaScript library, the bridge between them is typically a RESTful API that handles data fetching and updates. The Modern Architecture

In an updated stack, you move away from rendering HTML tables on the server. Instead, PHP acts as the backend engine—using a framework like Laravel or a simple Slim app—to serve JSON. AG Grid sits on the frontend, consuming that JSON. This separation allows for "Server-Side Row Model" features, where the grid only loads the data visible to the user, making it capable of handling millions of rows without crashing the browser. Data Fetching and CRUD An effective implementation involves a few key steps:

The API Endpoint: A PHP script queries your database (like MySQL) and returns the result as json_encode($data).

The Grid Configuration: On the frontend, you define columnDefs and use the fetch() API to pull from your PHP endpoint.

Updates: By using AG Grid's onCellValueChanged event, you can send an asynchronous POST or PUT request back to a PHP script to save changes to the database instantly. Security and Performance

Modern examples prioritize prepared statements (PDO) in PHP to prevent SQL injection. Additionally, with the latest AG Grid updates, you can leverage Integrated Charts and Advanced Filtering, which requires passing complex filter objects from the grid to your PHP logic to dynamically build the SQL query.

Integrating requires a bridge between your backend (MySQL/PostgreSQL) and the frontend grid via a JSON API. Because AG Grid is a client-side JavaScript library, the PHP portion focuses on serving data and handling server-side operations like pagination, filtering, and sorting. 1. Basic Project Structure

A modern AG Grid setup typically uses a "Fetch" pattern rather than direct PHP embedding: index.html : Loads the AG Grid library and initializes the grid. : Handles the gridOptions and fetches data from the backend. : Queries the database and returns a JSON-encoded array. 2. Frontend Setup (JavaScript)

To initialize the grid, you need to define column headers and a source. Using the latest setGridOption method is recommended for updates. javascript gridOptions = { columnDefs: [ field: , headerName: , field: , headerName: "Full Name" , field: , headerName: , sortable: // Use pagination for large datasets pagination: , paginationPageSize: // Initialize and Fetch Data gridDiv = document.querySelector( gridApi = agGrid.createGrid(gridDiv, gridOptions);

fetch( 'data.php'

) .then(response => response.json()) .then(data => gridApi.setGridOption( Use code with caution. Copied to clipboard 3. Backend Data Source (PHP) script serves as the API. Ensure you set the correct Content-Type header so the browser interprets it as JSON. query( "SELECT id, name, email FROM users" ); $results = $stmt->fetchAll(PDO::FETCH_ASSOC); // Output JSON for AG Grid json_encode($results); (PDOException $e) json_encode([ => $e->getMessage()]); ?> Use code with caution. Copied to clipboard 4. Advanced: Server-Side Row Model For datasets with millions of rows, use the AG Grid Enterprise Server-Side Row Model

: Instead of fetching all data at once, the grid sends a request to PHP containing the start row, end row, sort parameters, and filters. PHP Handling : Use these parameters to construct a SQL query to return only the visible slice of data. 5. Key Updates for 2026 Modularization

: AG Grid v33+ uses a modular system to reduce bundle size by 20-40%. : Use the new Theming API

for deeper CSS customization without overriding complex internal rules. Browser Support

: AG Grid 27+ has officially dropped support for Internet Explorer 11. AG Grid Blog CRUD example

(Create, Read, Update, Delete) showing how to send edits back to a PHP script? solidjs-community/solid-ag-grid - GitHub

Here are some of the features that make AG Grid stand out: * Grouping / Aggregation * * Accessibility support. * Custom Filtering. What's New in AG Grid 33

Building a High-Performance Data Grid: AG Grid & PHP (2026 Guide)

When your dataset grows from hundreds to hundreds of thousands of rows, client-side rendering isn't enough. You need a robust server-side strategy. Below is an updated guide and example for integrating AG Grid (v35+) 1. The Frontend: Modern AG Grid Setup For 2026, we utilize the Server-Side Row Model (SSRM)

. This allows the grid to only fetch the data it needs to display, rather than loading the entire database at once. < "https://jsdelivr.net" "height: 500px; width: 100%;" "ag-theme-alpine" > const columnDefs = [ field: 'agNumberColumnFilter' , field: 'agTextColumnFilter' , field: , field:

];

    const gridOptions = 
        columnDefs: columnDefs,
        rowModelType: 'serverSide'</p>

, // Enables SSRM pagination: true, paginationPageSize: , cacheBlockSize: ;

    const gridDiv = document.querySelector(</p>

); const api = agGrid.createGrid(gridDiv, gridOptions);

    // Fetch data from PHP backend
    const datasource = 
        getRows: (params) => 
            fetch( 'datasource.php' , 
                method:</p>

, body: JSON.stringify(params.request), headers: 'Content-Type' 'application/json'

) .then(response => response.json()) .then(data => params.success( rowData: data.rows, rowCount: data.total ); ) .catch(error => params.fail()); ;

    api.setGridOption( 'serverSideDatasource' , datasource);
</ Use code with caution. Copied to clipboard 2. The Backend: Scalable PHP Logic Your PHP script must handle the filterModel startRow/endRow parameters sent by AG Grid. Using is critical for security to prevent SQL injection. // datasource.php 'Content-Type: application/json' );

$input = json_decode(file_get_contents( 'php://input' ), true);

$startRow = $input[ 'startRow' ; $endRow = $input[ ; $limit = $endRow - $startRow; // Database Connection 'mysql:host=localhost;dbname=sports_db' // 1. Build the WHERE clause from AG Grid's filterModel " WHERE 1=1 " 'filterModel' 'filterModel' $col => $filter) // Simple example for text filter 'filterType' ) $where .= " AND $col LIKE " . $pdo->quote( . $filter[ ); // 2. Fetch Paginated Data "SELECT * FROM athletes $where LIMIT :start, :limit" ; $stmt = $pdo->prepare($sql); $stmt->bindValue( , (int)$startRow, PDO::PARAM_INT); $stmt->bindValue(

, (int)$limit, PDO::PARAM_INT); $stmt->execute(); $rows = $stmt->fetchAll(PDO::FETCH_ASSOC); // 3. Get Total Record Count for Pagination UI $totalSql = "SELECT COUNT(*) FROM athletes $where" ; $total = $pdo->query($totalSql)->fetchColumn(); json_encode([ => (int)$total ]); Use code with caution. Copied to clipboard Key Considerations for 2026 Version Updates : AG Grid v35 introduces improved Formula Editors BigInt support , making it ideal for financial PHP applications. : Always use prepared statements $pdo->quote() when handling filterModel keys to prevent malicious SQL injections. State Management : If you are using modern PHP frameworks like , consider leveraging its built-in paginators to simplify the server-side Excel export ChatGPT or Copilot – which is better for PHP development?

Title: The Grid That Wouldn't Wait

Logline: A junior developer’s routine update to an AG Grid PHP example spirals into a company-wide crisis when a legacy backend refuses to play nice with modern JavaScript.

The Story

Elara, a mid-level full-stack developer at DataViz Dynamics, stared at her Jira ticket. It was the kind of task everyone dreads: "TASK #4473 – Update AG Grid PHP Example on Dev Portal."

The existing example, a dusty "AG Grid + PHP/MySQL" demo, was five years old. It used AG Grid v23.2 (two major versions behind) and raw PHP mysqli with concatenated SQL. New users trying it out kept getting errors: "undefined property: data.lastModified" and "CORS preflight fails on PUT."

Her manager, Leo, had added a note: “Make it RESTful. Add streaming. Use AG Grid v31.3. And please, make it look like we know what year it is.”

Elara smiled. She loved AG Grid – its infinite scrolling, its cell editing, its ability to handle a million rows without breaking a sweat. But marrying it with a traditional PHP backend? That was the delicate dance.

She created a new folder: ag-grid-php-example-updated/.

Step 1: The Frontend Facelift

She wrote a modern JavaScript module:

// main.js
import  AgGridReact  from 'ag-grid-react';
import 'ag-grid-community/styles/ag-grid.css';
import 'ag-grid-community/styles/ag-theme-alpine.css';
const columnDefs = [
 field: 'id', filter: 'agNumberColumnFilter' ,
 field: 'product_name', editable: true, filter: 'agTextColumnFilter' ,
 field: 'price', editable: true, cellDataType: 'number' ,
 field: 'last_updated', cellRenderer: (params) => new Date(params.value).toLocaleString() 
];
const gridOptions = 
rowModelType: 'serverSide',  // Server-side pagination & filtering
serverSideStoreType: 'partial',
cacheBlockSize: 100,
columnDefs: columnDefs,
onCellValueChanged: (event) => fetch('/api/rows/update', 
method: 'PUT',
body: JSON.stringify( id: event.data.id, field: event.colDef.field, value: event.newValue )
)
;

Beautiful. Reactive. Editable inline.

Step 2: The PHP Middleware – The Updated Example

She wrote a modern server.php using Slim Framework 4 (instead of raw mysqli), with prepared statements, PDO, and server-side row model support:

<?php
// server.php - The "Updated" heart
use Psr\Http\Message\ResponseInterface as Response;
use Psr\Http\Message\ServerRequestInterface as Request;
use Slim\Factory\AppFactory;
use DI\Container;
require DIR . '/vendor/autoload.php';
$container = new Container();
$container->set('db', function() 
$pdo = new PDO('mysql:host=localhost;dbname=grid_demo;charset=utf8mb4', 'user', 'pass');
$pdo->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
return $pdo;
);
AppFactory::setContainer($container);
$app = AppFactory::create();
// Server-side row fetch for AG Grid
$app->post('/api/grid/rows', function (Request $request, Response $response) 
$params = $request->getParsedBody();
$startRow = $params['startRow'] ?? 0;
$endRow = $params['endRow'] ?? 100;
$limit = $endRow - $startRow;
// Filter & sort parsing (simplified)
$sql = "SELECT id, product_name, price, last_updated FROM products";
$countSql = "SELECT COUNT(*) as total FROM products";
$stmt = $this->get('db')->prepare("$sql LIMIT :offset, :limit");
$stmt->bindValue(':offset', $startRow, PDO::PARAM_INT);
$stmt->bindValue(':limit', $limit, PDO::PARAM_INT);
$stmt->execute();
$rows = $stmt->fetchAll(PDO::FETCH_ASSOC);
$totalStmt = $this->get('db')->query($countSql);
$totalRows = $totalStmt->fetch()['total'];
$result = [
    'rows' => $rows,
    'lastRow' => $totalRows
];
return $response->withHeader('Content-Type', 'application/json')->write(json_encode($result));

);
// Inline edit update
$app->put('/api/rows/update', function (Request $request, Response $response) 
$data = json_decode($request->getBody(), true);
$sql = "UPDATE products SET $data['field'] = :value WHERE id = :id";
$stmt = $this->get('db')->prepare($sql);
$stmt->execute([':value' => $data['value'], ':id' => $data['id']]);
return $response->withStatus(200);
);
$app->run();

She added detailed README.md explaining:

Step 3: The Unexpected Test

Elara pushed her branch: feature/update-ag-grid-php-example. She wrote a pull request with screenshots of the new grid – smooth infinite scroll, inline editing, server-side sorting.

But at 2:13 AM, the staging server crashed.

The logs showed a nightmare: "PHP Fatal error: Allowed memory size exhausted" when a user tried to export all 500,000 rows as CSV. The old example never had export. Her new grid had gridApi.exportDataAsCsv() – but that called the server-side post /api/grid/rows with startRow=0, endRow=null.

The PHP script tried to fetch half a million rows at once.

Step 4: The Fix and the Lesson

Elara rushed in at 7 AM. She realized: the updated example needed a streaming export endpoint, not a bulk load.

She added a new route:

$app->get('/api/export/csv', function (Request $request, Response $response) 
    $stmt = $this->get('db')->query("SELECT id, product_name, price, last_updated FROM products");
    $response = $response->withHeader('Content-Type', 'text/csv')
                         ->withHeader('Content-Disposition', 'attachment; filename="grid_export.csv"');
    $fh = fopen('php://output', 'w');
    fputcsv($fh, ['ID', 'Product Name', 'Price', 'Last Updated']);
    while ($row = $stmt->fetch(PDO::FETCH_ASSOC)) 
        fputcsv($fh, $row);
        ob_flush();
        flush();
fclose($fh);
    return $response;
);

She updated the AG Grid example to call this export URL instead of using gridApi.exportDataAsCsv() for large datasets, adding a note: "For large data, prefer server-side streaming export."

The Resolution

By 10 AM, the pull request was merged. The updated AG Grid PHP example was live on the dev portal, with:

That afternoon, Leo walked over. "The portal traffic doubled. Someone from a fintech startup said our example saved them three weeks of work."

Elara looked at her now-resolved Jira ticket. She added a final comment:

"Updated AG Grid PHP example to 2024 standards. Added streaming export, server-side row model, and a warning about memory limits. Note to self: never underestimate production data size."

She closed the ticket. The grid would wait for no one – but now, at least, it would handle a million rows without breaking. aggrid php example updated

End

Moral of the story: Updating an example isn’t just about new syntax – it’s about anticipating scale, securing data flow, and documenting the real-world pitfalls. And always test the export.

Implementing AG Grid with PHP involves a two-part architecture: a PHP backend to serve data (usually in JSON format) and a JavaScript frontend to render the grid. 1. The PHP Backend (data.php)

Your PHP script should fetch data from a database and return it as a JSON array. This is the "updated" way to handle modern grid requests.

query("SELECT id, name, model, price FROM cars"); $results = $stmt->fetchAll(PDO::FETCH_ASSOC); // Output as JSON for AG Grid echo json_encode($results); catch (PDOException $e) echo json_encode(['error' => $e->getMessage()]); ?> Use code with caution. Copied to clipboard 2. The Frontend Layout (index.html)

Use the latest AG Grid Community Edition via CDN. The script fetches data from your PHP file using fetch().

Grid Initialization: In newer versions (v31+), use agGrid.createGrid() instead of the older new agGrid.Grid().

Data Updates: Use gridApi.setGridOption('rowData', data) to dynamically refresh the grid.

Server-Side Operations: For massive datasets (millions of rows), consider AG Grid Enterprise which allows PHP to handle filtering and sorting directly on the server. Angular Grid: Upgrading to AG Grid 33.0

Integrating allows you to leverage a high-performance JavaScript frontend with a reliable server-side backend. While AG Grid is framework-agnostic on the frontend (supporting React, Angular, Vue, and Vanilla JS), it uses PHP on the server to handle data retrieval, filtering, and sorting for large datasets. Updated Implementation Summary The standard modern approach involves using a Server-Side Row Model (SSRM) to fetch data asynchronously via a PHP API. AG Grid Blog Frontend Setup

: Load the AG Grid library via CDN and define your grid container with a fixed height. Server-Side Logic : Your PHP script (e.g., ) queries a MySQL database and returns results as JSON. Data Exchange

: The grid sends parameters (like sort order and filter criteria) to PHP, which processes the SQL and sends back only the necessary rows. Detailed Feature Review

AG Grid remains a "gold standard" for data-intensive enterprise applications due to its extensive feature set and performance. Sample Apps, Demos, Examples & Extensions - AG Grid Blog 18 Jun 2025 —

This guide provides a modern implementation of AG Grid (version 35.x) using PHP 8.x as the backend. By 2026, standard practices for data grids have shifted toward using an API-first approach where PHP serves JSON to the client-side grid. 1. Front-End: Grid Setup

Modern AG Grid versions utilize createGrid rather than older constructor methods. This example uses the Client-Side Row Model for simplicity, which is ideal for datasets up to 100,000 rows.

In 2026, PHP is primarily used as an API layer to handle database operations securely. This updated example uses PDO with prepared statements to prevent SQL injection.

PDO::ERRMODE_EXCEPTION, PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC, ]); $action = $_GET['action'] ?? ''; if ($action === 'read') // Fetch data for the grid $stmt = $pdo->query("SELECT id, name, email, role FROM users"); echo json_encode($stmt->fetchAll()); if ($action === 'update') // Basic CRUD update example $data = json_decode(file_get_contents('php://input'), true); $stmt = $pdo->prepare("UPDATE users SET name = ?, email = ? WHERE id = ?"); $stmt->execute([$data['name'], $data['email'], $data['id']]); echo json_encode(['status' => 'success']); ?> Use code with caution. Copied to clipboard 3. Key 2026 Best Practices

Virtualization: AG Grid enables row and column virtualization by default to handle large data efficiently.

Server-Side Row Model (SSRM): For millions of rows, use rowModelType: 'serverSide' to lazy-load data in chunks.

Immutable Data: Enable immutableData: true and provide a getRowId function (using your database primary key) to optimize re-renders during updates.

Security: Always use POST/PUT for updates and ensure your PHP backend validates all incoming JSON data. AG Grid What's new

Create an index.html file using AG Grid v31+ with the server-side row model.

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>AG Grid PHP Example – Updated Server-Side</title>
    <script src="https://cdn.jsdelivr.net/npm/ag-grid-community@31.3.2/dist/ag-grid-community.min.js"></script>
    <style>
        html, body  height: 100%; margin: 0; 
        .ag-theme-alpine  height: 90vh; width: 100%; 
    </style>
</head>
<body>
    <div id="myGrid" class="ag-theme-alpine"></div>
<script>
    // Define columns
    const columnDefs = [
         field: "id", sortable: true, filter: "agNumberColumnFilter" ,
         field: "product_name", headerName: "Product Name", sortable: true, filter: "agTextColumnFilter" ,
         field: "category", sortable: true, filter: "agSetColumnFilter" ,
         field: "price", sortable: true, filter: "agNumberColumnFilter" ,
         field: "stock_quantity", headerName: "Stock", sortable: true ,
         field: "last_updated", headerName: "Last Updated", sortable: true, filter: "agDateColumnFilter" 
    ];
// Server-side datasource
    const dataSource = 
        getRows: async (params) => 
            const request = 
                startRow: params.request.startRow,
                endRow: params.request.endRow,
                sortModel: params.request.sortModel,
                filterModel: params.request.filterModel
            ;
try 
                const response = await fetch('http://localhost/aggregid-php/api/get-rows.php', 
                    method: 'POST',
                    headers:  'Content-Type': 'application/json' ,
                    body: JSON.stringify(request)
                );
                const result = await response.json();
                params.successCallback(result.rows, result.lastRow);
             catch (error) 
                console.error('AG Grid fetch failed:', error);
                params.failCallback();
;
const gridOptions = 
        columnDefs: columnDefs,
        rowModelType: 'serverSide',
        serverSideStoreType: 'partial',
        cacheBlockSize: 100,
        pagination: true,
        paginationPageSize: 100,
        animateRows: true
    ;
const gridDiv = document.querySelector('#myGrid');
    const gridApi = agGrid.createGrid(gridDiv, gridOptions);
    gridApi.setGridOption('serverSideDatasource', dataSource);
</script>

</body>
</html>

| Old/Incorrect | Updated Solution | |---------------|------------------| | mysql_query() | PDO with prepared statements | | Returning all rows at once | Server-side row model | | Ignoring filterModel type | Handle contains, equals, greaterThan, etc. | | $_GET for parameters | Use php://input and JSON | | Hardcoded OFFSET without validating | Cast to (int) to prevent injection | | No lastRow calculation | Always return total filtered count |

If the PHP example constructs database queries based on AG Grid's request parameters (like filtering or sorting), there is a high risk of SQL Injection if not handled correctly. AG Grid’s server-side row model requires specific request