docs: update documentation for PostgreSQL support (1.1.0)

- sql-dialects.md: add POSTGRESQL to overview table, usage example,
  dialect matrix, AbstractSqlDialect section, and interface table
- conditions.md: add ILIKE/NOT_ILIKE to Operator table and builder
  method reference table
- dml-builders.md: add RETURNING clause section with DELETE/INSERT/UPDATE
  examples; add returning() to InsertBuilder, UpdateBuilder, DeleteBuilder
  method reference tables
- index.md: bump badges and version snippet to 1.1.0, update operator
  count (16→18), dialect list (Three→Four, add POSTGRESQL), docs table
- installation.md: bump Maven, Gradle, and GitHub Packages version
  snippets from 1.0.4 to 1.1.0

Author: ez-plugins

docs/conditions.md

@@ -50,6 +50,8 @@ conditions use `AND` by default; call the `orWhere*` variant to use `OR`.
 | `BETWEEN` | `col BETWEEN ? AND ?` | Inclusive range; value is a two-element `List<?>` |
 | `EXISTS_SUBQUERY` | `EXISTS (SELECT ...)` | Value is a `Query`; column is `null` |
 | `NOT_EXISTS_SUBQUERY` | `NOT EXISTS (SELECT ...)` | Value is a `Query`; column is `null` |
+| `ILIKE` | `col ILIKE ?` | Case-insensitive substring match — **PostgreSQL only** |
+| `NOT_ILIKE` | `col NOT ILIKE ?` | Negated case-insensitive match — **PostgreSQL only** |
 
 ---
 
@@ -69,6 +71,8 @@ constant and the SQL it generates.
 | `whereLessThanOrEquals(col, val)` | `LTE` | `col <= ?` |
 | `whereLike(col, val)` | `LIKE` | `col LIKE ?` |
 | `whereNotLike(col, val)` | `NOT_LIKE` | `col NOT LIKE ?` |
+| `whereILike(col, val)` | `ILIKE` | `col ILIKE ?` (PostgreSQL only) |
+| `orWhereILike(col, val)` | `ILIKE` | `OR col ILIKE ?` (PostgreSQL only) |
 | `whereNull(col)` | `IS_NULL` | `col IS NULL` |
 | `whereNotNull(col)` | `IS_NOT_NULL` | `col IS NOT NULL` |
 | `whereExists(col)` | `EXISTS` | `col IS NOT NULL` |

docs/dml-builders.md

@@ -61,6 +61,7 @@ SqlResult result = QueryBuilder.insertInto("users")
 |--------|---------|-------------|
 | `into(String table)` | `InsertBuilder` | Set target table (also available via factory) |
 | `value(String col, Object val)` | `InsertBuilder` | Add a column/value pair |
+| `returning(String... cols)` | `InsertBuilder` | Append `RETURNING col1, col2, ...` (PostgreSQL only) |
 | `build()` | `SqlResult` | Render with standard dialect |
 | `build(SqlDialect dialect)` | `SqlResult` | Render with specified dialect |
 
@@ -111,6 +112,7 @@ SqlResult result = QueryBuilder.update("users")
 | `whereEquals(String col, Object val)` | `UpdateBuilder` | `WHERE col = ?` (AND) |
 | `orWhereEquals(String col, Object val)` | `UpdateBuilder` | `WHERE col = ?` (OR) |
 | `whereGreaterThanOrEquals(String col, int val)` | `UpdateBuilder` | `WHERE col >= ?` (AND) |
+| `returning(String... cols)` | `UpdateBuilder` | Append `RETURNING col1, col2, ...` (PostgreSQL only) |
 | `build()` | `SqlResult` | Render with standard dialect |
 | `build(SqlDialect dialect)` | `SqlResult` | Render with specified dialect |
 
@@ -186,11 +188,65 @@ SqlResult result = SqlDialect.MYSQL.renderDelete(q);
 | `whereIn(col, List<?>)` | `DeleteBuilder` | `WHERE col IN (...)` (AND) |
 | `whereNotIn(col, List<?>)` | `DeleteBuilder` | `WHERE col NOT IN (...)` (AND) |
 | `whereBetween(col, from, to)` | `DeleteBuilder` | `WHERE col BETWEEN ? AND ?` (AND) |
+| `returning(String... cols)` | `DeleteBuilder` | Append `RETURNING col1, col2, ...` (PostgreSQL only; use with `SqlDialect.POSTGRESQL`) |
 | `build()` | `SqlResult` | Render with standard dialect |
 | `build(SqlDialect dialect)` | `SqlResult` | Render with specified dialect |
 
 ---
 
+## RETURNING clause (PostgreSQL)
+{: #returning-clause-postgresql }
+
+All three DML builders support a `RETURNING` clause for PostgreSQL, which
+lets the database return column values from affected rows in a single round-trip.
+
+### DELETE … RETURNING
+
+`RETURNING` on `DELETE` is rendered by the dialect — it is only appended when
+`SqlDialect.POSTGRESQL` (or another dialect that overrides `supportsReturning()`)
+is active.
+
+```java
+SqlResult result = QueryBuilder.deleteFrom("users")
+    .whereEquals("id", 99)
+    .returning("id", "email")
+    .build(SqlDialect.POSTGRESQL);
+
+// → DELETE FROM "users" WHERE "id" = ? RETURNING id, email
+// Parameters: [99]
+```
+
+### INSERT … RETURNING
+
+`RETURNING` on `INSERT` is appended inline regardless of dialect — the caller
+is responsible for using a PostgreSQL connection.
+
+```java
+SqlResult result = QueryBuilder.insertInto("users")
+    .value("name", "Alice")
+    .value("email", "alice@example.com")
+    .returning("id", "created_at")
+    .build();
+
+// → INSERT INTO users (name, email) VALUES (?, ?) RETURNING id, created_at
+// Parameters: ["Alice", "alice@example.com"]
+```
+
+### UPDATE … RETURNING
+
+```java
+SqlResult result = QueryBuilder.update("users")
+    .set("status", "active")
+    .whereEquals("id", 7)
+    .returning("id", "updated_at")
+    .build();
+
+// → UPDATE users SET status = ? WHERE id = ? RETURNING id, updated_at
+// Parameters: ["active", 7]
+```
+
+---
+
 ## CreateBuilder
 
 ### Basic CREATE TABLE

docs/index.md

@@ -9,7 +9,7 @@ permalink: /
 # JavaQueryBuilder
 
 [![JitPack](https://jitpack.io/v/EzFramework/JavaQueryBuilder.svg)](https://jitpack.io/#EzFramework/JavaQueryBuilder)
-[![GitHub Packages](https://img.shields.io/badge/GitHub_Packages-1.0.4-blue?logo=github)](https://github.com/EzFramework/JavaQueryBuilder/packages)
+[![GitHub Packages](https://img.shields.io/badge/GitHub_Packages-1.1.0-blue?logo=github)](https://github.com/EzFramework/JavaQueryBuilder/packages)
 
 **JavaQueryBuilder** is a lightweight, fluent Java library for building
 parameterized SQL queries and filtering in-memory data.
@@ -24,12 +24,12 @@ No runtime dependencies required.
 - **DML builders**: `InsertBuilder`, `UpdateBuilder`, `DeleteBuilder`, `CreateBuilder`
 - **Parameterized-only**: user values always go through `?` bind parameters; SQL injection
   is structurally impossible
-- **16 operators**: equality, comparison, `LIKE`, `NULL` checks, `IN`, `BETWEEN`,
+- **18 operators**: equality, comparison, `LIKE`, `ILIKE` (PostgreSQL), `NULL` checks, `IN`, `BETWEEN`,
   `EXISTS`, and subquery operators
 - **Subquery support**: `WHERE col IN (SELECT ...)`, `WHERE EXISTS (SELECT ...)`,
   `WHERE NOT EXISTS (SELECT ...)`, scalar `WHERE col = (SELECT ...)`,
   FROM-derived table, JOIN subquery, and scalar `SELECT` items
-- **Three SQL dialects**: `STANDARD` (ANSI), `MYSQL` (back-tick quoting), `SQLITE` (double-quote)
+- **Four SQL dialects**: `STANDARD` (ANSI), `MYSQL` (back-tick quoting), `SQLITE` (double-quote), `POSTGRESQL` (double-quote + `ILIKE` + `RETURNING`)
 - **Global and per-query configuration** via `QueryBuilderDefaults`: preset dialect, default
   columns, limit, offset, and LIKE wrapping once at application startup
 - **In-memory filtering**: `QueryableStorage` functional interface applies the same `Query`
@@ -53,7 +53,7 @@ No runtime dependencies required.
 <dependency>
   <groupId>com.github.EzFramework</groupId>
   <artifactId>JavaQueryBuilder</artifactId>
-  <version>1.0.4</version>
+  <version>1.1.0</version>
 </dependency>
 ```
 
@@ -104,9 +104,9 @@ SqlResult update = QueryBuilder.update("users")
 | [Installation](installation) | Maven, Gradle, JitPack, GitHub Packages |
 | [Query Builder](query-builder) | SELECT: `from`, `select`, `where*`, `orderBy`, `build` |
 | [DML Builders](dml-builders) | `InsertBuilder`, `UpdateBuilder`, `DeleteBuilder`, `CreateBuilder` |
-| [Conditions](conditions) | All 16 operators, `Condition`, `ConditionEntry`, `Connector` |
+| [Conditions](conditions) | All 18 operators, `Condition`, `ConditionEntry`, `Connector` |
 | [Subqueries](subqueries) | All six subquery variants |
-| [SQL Dialects](sql-dialects) | `STANDARD`, `MYSQL`, `SQLITE`, `SqlResult`, dialect matrix |
+| [SQL Dialects](sql-dialects) | `STANDARD`, `MYSQL`, `SQLITE`, `POSTGRESQL`, `SqlResult`, dialect matrix |
 | [Configuration](configuration) | `QueryBuilderDefaults`: global and per-query dialect, columns, limit, LIKE wrapping |
 | [In-Memory Filtering](in-memory) | `QueryableStorage`: filter collections without a database |
 | [Exceptions](exceptions) | Error hierarchy and handling patterns |

docs/installation.md

@@ -46,7 +46,7 @@ your classpath.
 <dependency>
   <groupId>com.github.EzFramework</groupId>
   <artifactId>JavaQueryBuilder</artifactId>
-  <version>1.0.4</version>
+  <version>1.1.0</version>
 </dependency>
 ```
 
@@ -66,7 +66,7 @@ repositories {
 
 ```kotlin
 dependencies {
-    implementation("com.github.EzFramework:JavaQueryBuilder:1.0.4")
+    implementation("com.github.EzFramework:JavaQueryBuilder:1.1.0")
 }
 ```
 
@@ -102,7 +102,7 @@ authenticate with a personal access token that has `read:packages` scope.
 <dependency>
   <groupId>com.github.EzFramework</groupId>
   <artifactId>java-query-builder</artifactId>
-  <version>1.0.4</version>
+  <version>1.1.0</version>
 </dependency>
 ```
 

docs/sql-dialects.md

@@ -21,11 +21,12 @@ description: "SqlDialect, SqlResult, AbstractSqlDialect, and the dialect matrix"
 parameterized `SqlResult`. Three built-in dialects are provided as constants
 on the interface:
 
-| Constant | Identifier quoting | DELETE LIMIT |
-|----------|--------------------|--------------|
-| `SqlDialect.STANDARD` | None (ANSI) | Not supported |
-| `SqlDialect.MYSQL` | Back-tick `` ` `` | Supported |
-| `SqlDialect.SQLITE` | Double-quote `"` | Supported |
+| Constant | Identifier quoting | DELETE LIMIT | ILIKE | RETURNING |
+|----------|--------------------|--------------| ------|----------|
+| `SqlDialect.STANDARD` | None (ANSI) | Not supported | No | No |
+| `SqlDialect.MYSQL` | Back-tick `` ` `` | Supported | No | No |
+| `SqlDialect.SQLITE` | Double-quote `"` | Supported | No | No |
+| `SqlDialect.POSTGRESQL` | Double-quote `"` | Not supported | Yes | Yes (DELETE) |
 
 ---
 
@@ -54,6 +55,14 @@ SqlResult r3 = new QueryBuilder()
     .whereEquals("id", 1)
     .buildSql(SqlDialect.SQLITE);
 // → SELECT * FROM "users" WHERE "id" = ?
+
+// PostgreSQL: double-quoted identifiers + ILIKE support
+SqlResult r4 = new QueryBuilder()
+    .from("users")
+    .whereILike("email", "alice")
+    .buildSql(SqlDialect.POSTGRESQL);
+// → SELECT * FROM "users" WHERE "email" ILIKE ?
+// Parameters: ["%alice%"]
 ```
 
 ---
@@ -87,7 +96,8 @@ List<Object> params = result.getParameters();
 ## Rendering DELETE statements
 
 Use `renderDelete(Query)` on a dialect instance to produce `DELETE FROM ...`
-statements. This respects the `LIMIT` clause on dialects that support it.
+statements. This respects the `LIMIT` clause on dialects that support it and
+the `RETURNING` clause on PostgreSQL.
 
 ```java
 Query q = new QueryBuilder()
@@ -109,25 +119,30 @@ SqlResult sq = SqlDialect.SQLITE.renderDelete(q);
 // → DELETE FROM "sessions" WHERE "expired" = ? LIMIT 500
 ```
 
+For PostgreSQL `RETURNING`, use `DeleteBuilder.returning()` — see [DML Builders](dml-builders#returning-clause-postgresql).
+
 ---
 
 ## Dialect matrix
 
 The same `Query` produces different SQL across dialects due to identifier quoting:
 
-| Feature | STANDARD | MYSQL | SQLITE |
-|---------|----------|-------|--------|
-| Table quoting | `users` | `` `users` `` | `"users"` |
-| Column quoting | `id` | `` `id` `` | `"id"` |
-| DELETE LIMIT | No | Yes | Yes |
-| Parameter syntax | `?` | `?` | `?` |
+| Feature | STANDARD | MYSQL | SQLITE | POSTGRESQL |
+|---------|----------|-------|--------|------------|
+| Table quoting | `users` | `` `users` `` | `"users"` | `"users"` |
+| Column quoting | `id` | `` `id` `` | `"id"` | `"id"` |
+| DELETE LIMIT | No | Yes | Yes | No |
+| ILIKE / NOT ILIKE | No | No | No | Yes |
+| RETURNING on DELETE | No | No | No | Yes |
+| Parameter syntax | `?` | `?` | `?` | `?` |
 
 ---
 
 ## AbstractSqlDialect
 
 `AbstractSqlDialect` implements the shared rendering logic for SELECT and DELETE
-queries. It is the base class for both `MySqlDialect` and `SqliteDialect`.
+queries. It is the base class for `MySqlDialect`, `SqliteDialect`, and
+`PostgreSqlDialect`.
 
 **Subquery parameter ordering**: parameters are collected depth-first in this
 order:
@@ -137,17 +152,9 @@ order:
 3. JOIN subquery parameters (left to right)
 4. WHERE condition subquery parameters (top to bottom)
 
-To create a custom dialect (e.g. PostgreSQL with `"..."` quoting), extend
-`AbstractSqlDialect` and override `quoteIdentifier`:
-
-```java
-public class PostgreSqlDialect extends AbstractSqlDialect {
-    @Override
-    protected String quoteIdentifier(String name) {
-        return '"' + name + '"';
-    }
-}
-```
+To create a fully custom dialect, extend `AbstractSqlDialect` and override any
+combination of `quoteIdentifier`, `supportsDeleteLimit`, `supportsReturning`,
+and `appendConditionFragment`.
 
 ---
 
@@ -158,5 +165,6 @@ public class PostgreSqlDialect extends AbstractSqlDialect {
 | `SqlDialect.STANDARD` | ANSI SQL constant instance |
 | `SqlDialect.MYSQL` | MySQL dialect constant instance |
 | `SqlDialect.SQLITE` | SQLite dialect constant instance |
+| `SqlDialect.POSTGRESQL` | PostgreSQL dialect constant instance |
 | `render(Query)` | Render a `SELECT` query to `SqlResult` |
-| `renderDelete(Query)` | Render a `DELETE` query to `SqlResult`; observes `LIMIT` on supporting dialects |
+| `renderDelete(Query)` | Render a `DELETE` query to `SqlResult`; observes `LIMIT` and `RETURNING` on supporting dialects |