Server examples (Java, Node, Python, PHP, C#, Go)

// Spring Boot + JdbcTemplate.  restDatasource('/api/orders/rows'), saveChanges(grid, '/api/orders/save')
@RestController
@RequestMapping("/api/orders")
public class OrderController {

    /** Grid column id → SQL column. Only these can be sorted, filtered or grouped. */
    private static final GridQuery QUERY = new GridQuery()
        .column("orderNo", "ORDER_NO", GridQuery.Type.TEXT)
        .column("orderDate", "ORDER_DATE", GridQuery.Type.DATE)
        .column("status", "STATUS", GridQuery.Type.TEXT)
        .column("qty", "QTY", GridQuery.Type.NUMBER)
        .defaultOrderBy("ID");
    // .dialect(GridQuery.Dialect.LIMIT) for MySQL, MariaDB, PostgreSQL (LIMIT ? OFFSET ?)

    private final JdbcTemplate jdbc;
    public OrderController(JdbcTemplate jdbc) { this.jdbc = jdbc; }

    @PostMapping("/rows")
    public Map<String, Object> rows(@RequestBody Map<String, Object> body) {
        GridQuery.Sql sql = QUERY.build(GridRequest.from(body));
        Long total = jdbc.queryForObject("SELECT COUNT(*) FROM ORDERS" + sql.where, Long.class, sql.countArgs());
        List<Map<String, Object>> rows = jdbc.queryForList(
            "SELECT ID AS \"id\", ORDER_NO AS \"orderNo\", ORDER_DATE AS \"orderDate\", STATUS AS \"status\", QTY AS \"qty\" FROM ORDERS"
                + sql.where + sql.orderBy + sql.page, sql.pageArgs());
        return GridRows.of(rows, total);              // { rows, total }, dates as "YYYY-MM-DD"
    }

    @PostMapping("/save")
    @Transactional
    public Map<String, Object> save(@RequestBody Map<String, Object> body) {
        GridSave save = GridSave.from(body);          // created / updated / deleted
        for (Map<String, Object> r : save.getDeleted()) jdbc.update("DELETE FROM ORDERS WHERE ID = ?", r.get("id"));
        for (Map<String, Object> r : save.getUpdated())
            jdbc.update("UPDATE ORDERS SET STATUS = ?, QTY = ? WHERE ID = ?", r.get("status"), r.get("qty"), r.get("id"));
        for (Map<String, Object> r : save.getCreated())
            jdbc.update("INSERT INTO ORDERS (ORDER_NO, ORDER_DATE, STATUS, QTY) VALUES (?, ?, ?, ?)",
                r.get("orderNo"), GridSave.date(r.get("orderDate")), r.get("status"), r.get("qty"));
        return Collections.singletonMap("ok", true);
    }

    /** Bad numbers, dates or filter ops answer 400 instead of 500. */
    @ExceptionHandler(IllegalArgumentException.class)
    public ResponseEntity<Map<String, Object>> bad(IllegalArgumentException e) {
        return ResponseEntity.badRequest().body(Collections.singletonMap("message", e.getMessage()));
    }
}

// eGovFrame (MyBatis): the service builds the SQL pieces, the mapper XML puts them in place
@Service("orderService")
public class OrderServiceImpl extends EgovAbstractServiceImpl implements OrderService {

    private static final GridQuery QUERY = new GridQuery()
        .column("orderNo", "ORDER_NO", GridQuery.Type.TEXT)
        .column("orderDate", "ORDER_DATE", GridQuery.Type.DATE)
        .column("status", "STATUS", GridQuery.Type.TEXT)
        .column("qty", "QTY", GridQuery.Type.NUMBER)
        .defaultOrderBy("ID");

    @Resource(name = "orderMapper")
    private OrderMapper orderMapper;

    @Override
    public Map<String, Object> selectOrders(Map<String, Object> body) throws Exception {
        GridQuery.Sql sql = QUERY.buildForMyBatis(GridRequest.from(body));
        Map<String, Object> query = new HashMap<String, Object>();
        query.put("where", sql.getWhere());           // " WHERE STATUS = #{params.p0} ..."
        query.put("orderBy", sql.getOrderBy());
        query.put("page", sql.getPage());
        query.put("params", sql.getParams());         // the bound values
        long total = orderMapper.selectOrderCount(query);
        return GridRows.of(orderMapper.selectOrderList(query), total);
    }
}

// Controller: @RequestMapping("/order/selectOrders.do") @ResponseBody
//   public Map<String, Object> select(@RequestBody Map<String, Object> body) throws Exception { return orderService.selectOrders(body); }

<!-- where / orderBy / page hold only the allowed column names and #{params.pN};
     the values are bound by MyBatis, so request data never becomes SQL text -->
<mapper namespace="egovframework.example.order.service.impl.OrderMapper">

  <select id="selectOrderList" parameterType="map" resultType="hashmap">
    SELECT ID AS "id", ORDER_NO AS "orderNo", ORDER_DATE AS "orderDate", STATUS AS "status", QTY AS "qty"
      FROM ORDERS
    ${where}
    ${orderBy}
    ${page}
  </select>

  <select id="selectOrderCount" parameterType="map" resultType="long">
    SELECT COUNT(*) FROM ORDERS
    ${where}
  </select>
</mapper>

import { createQuery, readRequest, readSave, toRows } from './freegrid-query.js';

const QUERY = createQuery({
  columns: {                                   // grid column id → SQL column: only these can be sorted / filtered
    orderNo: { sql: 'ORDER_NO', type: 'text' },
    orderDate: { sql: 'ORDER_DATE', type: 'date' },
    qty: { sql: 'QTY', type: 'number' },
  },
  dialect: 'limit',                            // SQL Server / Oracle: 'standard'; pg: placeholder: 'dollar'
  defaultOrderBy: 'ID',
});

app.post('/api/orders/rows', (req, res) => {
  const sql = QUERY.build(readRequest(req.body));
  const total = db.prepare('SELECT COUNT(*) AS n FROM ORDERS' + sql.where).get(sql.countArgs).n;
  const rows = db.prepare(SELECT + sql.where + sql.orderBy + sql.page).all(sql.args);
  res.json(toRows(rows, total));               // { rows, total }, dates as "YYYY-MM-DD"
});

app.post('/api/orders/save', (req, res) => {
  const { created, updated, deleted } = readSave(req.body);
  // INSERT / UPDATE / DELETE in one transaction
});

from freegrid_query import Column, GridQuery, read_request, read_save, to_rows

QUERY = GridQuery(
    columns={
        "orderNo": Column("ORDER_NO", "text"),
        "orderDate": Column("ORDER_DATE", "date"),
        "qty": Column("QTY", "number"),
    },
    dialect="limit",          # SQL Server / Oracle: "standard"
    paramstyle="qmark",       # psycopg / PyMySQL: "format"; oracledb: "named"
    default_order_by="ID",
)

@app.post("/api/orders/rows")
async def rows(request: Request):
    sql = QUERY.build(read_request(await request.json()))
    total = db.execute("SELECT COUNT(*) FROM ORDERS" + sql.where, sql.count_args).fetchone()[0]
    found = db.execute(SELECT + sql.where + sql.order_by + sql.page, sql.args).fetchall()
    return to_rows(found, total)

@app.post("/api/orders/save")
async def save(request: Request):
    changes = read_save(await request.json())   # created / updated / deleted

use FreeGrid\FreeGridQuery;

const COLUMNS = [
    'orderNo' => ['ORDER_NO', 'text'],
    'orderDate' => ['ORDER_DATE', 'date'],
    'qty' => ['QTY', 'number'],
];

$query = new FreeGridQuery(COLUMNS, dialect: 'limit', defaultOrderBy: 'ID'); // SQL Server / Oracle: 'standard'
$sql = $query->build(FreeGridQuery::readRequest($body));

$count = $pdo->prepare('SELECT COUNT(*) FROM ORDERS' . $sql['where']);
FreeGridQuery::bind($count, $sql['countArgs']);
$count->execute();
$st = $pdo->prepare(SELECT . $sql['where'] . $sql['orderBy'] . $sql['page']);
FreeGridQuery::bind($st, $sql['args']);
$st->execute();
echo json_encode(FreeGridQuery::toRows($st->fetchAll(), $count->fetchColumn()));

// Laravel: call the same code from a controller with $request->json()->all()

using FreeGrid;

var query = new FreeGridQuery()
    .Column("orderNo", "ORDER_NO", ColumnType.Text)
    .Column("orderDate", "ORDER_DATE", ColumnType.Date)
    .Column("qty", "QTY", ColumnType.Number)
    .UseDialect(Dialect.Limit)              // SQL Server / Oracle: Dialect.Standard
    .DefaultOrderBy("ID");

app.MapPost("/api/orders/rows", async (HttpRequest http) =>
{
    var sql = query.Build(GridRequest.From(await ReadBody(http)));
    await using var conn = new SqliteConnection(Db);
    await conn.OpenAsync();
    var count = conn.CreateCommand();
    count.CommandText = "SELECT COUNT(*) FROM ORDERS" + sql.Where;
    sql.AddParameters(count, count: true);
    long total = (long)(await count.ExecuteScalarAsync())!;
    var select = conn.CreateCommand();
    select.CommandText = Select + sql.Where + sql.OrderBy + sql.Page;
    sql.AddParameters(select);
    await using var reader = await select.ExecuteReaderAsync();
    return Results.Json(GridRows.Of(await GridRows.Read(reader), total));
});

import "example.com/app/freegrid"

var query = &freegrid.Query{
	Columns: map[string]freegrid.Column{
		"orderNo":   {SQL: "ORDER_NO", Type: freegrid.Text},
		"orderDate": {SQL: "ORDER_DATE", Type: freegrid.Date},
		"qty":       {SQL: "QTY", Type: freegrid.Number},
	},
	Dialect:        freegrid.Limit,    // SQL Server / Oracle: freegrid.Standard
	Placeholder:    freegrid.Question, // pgx / lib/pq: freegrid.Dollar
	DefaultOrderBy: "ID",
}

func rows(db *sql.DB, body []byte) (any, error) {
	req, err := freegrid.ReadRequest(body)
	if err != nil {
		return nil, err // freegrid.IsGridError(err) → 400
	}
	q, err := query.Build(req)
	if err != nil {
		return nil, err
	}
	var total int64
	if err := db.QueryRow("SELECT COUNT(*) FROM ORDERS"+q.Where, q.CountArgs...).Scan(&total); err != nil {
		return nil, err
	}
	res, err := db.Query(selectOrders+q.Where+q.OrderBy+q.Page, q.Args...)
	if err != nil {
		return nil, err
	}
	found, err := freegrid.ReadRows(res) // dates as "YYYY-MM-DD"
	if err != nil {
		return nil, err
	}
	return map[string]any{"rows": found, "total": total}, nil
}