mirror of https://github.com/redis/redis.git
Merge 20eeaab0d1 into 3c1a759954
This commit is contained in:
RaphaelDrai
GitHub
commit
87e0a62c0a
|
|
@ -0,0 +1,42 @@
|
|||
# Redis Table Module Makefile
|
||||
# Author: Raphael Drai
|
||||
# Date: October 3, 2025
|
||||
|
||||
# Configuration
|
||||
MODULE_NAME = redis_table
|
||||
REDIS_SRC = ../../src
|
||||
CC = gcc
|
||||
CFLAGS = -Wall -Werror -g -O0 -fPIC -I$(REDIS_SRC)
|
||||
|
||||
# Default target: build the module
|
||||
all: $(MODULE_NAME).so
|
||||
|
||||
# Build the shared library
|
||||
$(MODULE_NAME).so: $(MODULE_NAME).o
|
||||
$(CC) -shared -o $@ $^
|
||||
|
||||
# Compile the source file
|
||||
$(MODULE_NAME).o: $(MODULE_NAME).c
|
||||
$(CC) $(CFLAGS) -c $<
|
||||
|
||||
# Clean build artifacts
|
||||
clean:
|
||||
rm -f $(MODULE_NAME).o $(MODULE_NAME).so
|
||||
|
||||
# Run tests
|
||||
test: $(MODULE_NAME).so
|
||||
@echo "Running Redis Table Module tests..."
|
||||
@cd tests && ./run_tests.sh
|
||||
|
||||
# Debug target - build and provide debug info
|
||||
debug: $(MODULE_NAME).so
|
||||
@echo "Module built: $(MODULE_NAME).so"
|
||||
@echo "To debug: gdb --args $(REDIS_SRC)/redis-server --loadmodule $(PWD)/$(MODULE_NAME).so"
|
||||
|
||||
# Install target (optional)
|
||||
install: $(MODULE_NAME).so
|
||||
@echo "Installing $(MODULE_NAME).so to /usr/local/lib/redis/modules/"
|
||||
@mkdir -p /usr/local/lib/redis/modules/
|
||||
@cp $(MODULE_NAME).so /usr/local/lib/redis/modules/
|
||||
|
||||
.PHONY: all clean test debug install
|
||||
|
|
@ -0,0 +1,562 @@
|
|||
# Redis Table Module - Complete Guide
|
||||
|
||||
A Redis module that implements SQL-like tables with full CRUD operations, explicit index control, comparison operators, and support for multiple data types.
|
||||
|
||||
## Requirements Summary
|
||||
|
||||
1. ✅ Create SQL-like tables with namespace
|
||||
2. ✅ Namespace must be created before tables
|
||||
3. ✅ Full CRUD operations (CREATE, INSERT, SELECT, UPDATE, DELETE, DROP)
|
||||
4. ✅ Automatic row ID generation
|
||||
5. ✅ Index management (auto-create, auto-update, auto-remove)
|
||||
6. ✅ Explicit index control (define which columns are indexed)
|
||||
7. ✅ Dynamic table schema modification (ADD/DROP columns and indexes)
|
||||
8. ✅ TABLE.SCHEMA.VIEW command to display schema
|
||||
9. ✅ Support for string, integer, float, and date types
|
||||
10. ✅ Comparison operators: =, >, <, >=, <=
|
||||
11. ✅ AND/OR operators in WHERE clause
|
||||
12. ✅ Index validation (equality searches require indexed columns)
|
||||
|
||||
## Build
|
||||
|
||||
The module includes a fully functional Makefile with the following targets:
|
||||
|
||||
```bash
|
||||
# Build the module
|
||||
make
|
||||
|
||||
# Clean build artifacts
|
||||
make clean
|
||||
|
||||
# Run comprehensive test suite (86 tests)
|
||||
make test
|
||||
|
||||
# Build with debug information
|
||||
make debug
|
||||
```
|
||||
|
||||
### Manual Build (if needed)
|
||||
```bash
|
||||
cd /home/ubuntu/Projects/REDIS/redis/modules/redistable
|
||||
gcc -Wall -Werror -g -O0 -fPIC -I../../src -c redis_table.c
|
||||
gcc -shared -o redis_table.so redis_table.o
|
||||
```
|
||||
|
||||
## Run Redis with Module
|
||||
|
||||
```bash
|
||||
# From the redistable directory
|
||||
cd /home/ubuntu/Projects/REDIS/redis/modules/redistable
|
||||
|
||||
# Start Redis with the module loaded
|
||||
cd ../../..
|
||||
./src/redis-server --loadmodule modules/redistable/redis_table.so
|
||||
|
||||
# In another terminal
|
||||
./src/redis-cli
|
||||
```
|
||||
|
||||
### Quick Test
|
||||
```bash
|
||||
# Build and test the module
|
||||
cd /home/ubuntu/Projects/REDIS/redis/modules/redistable
|
||||
make clean && make && make test
|
||||
```
|
||||
|
||||
## Supported Data Types
|
||||
|
||||
| Type | Format | Example | Validation | Comparison |
|
||||
|---------|-----------------|---------------|-------------------------------------|------------|
|
||||
| string | Any text | `"Hello"` | None | Lexical |
|
||||
| integer | Whole number | `123`, `-45` | Digits only, optional +/- prefix | Numeric |
|
||||
| float | Decimal number | `123.45` | Digits + optional decimal point | Numeric |
|
||||
| date | YYYY-MM-DD | `2024-01-15` | Exactly 10 chars, hyphens at 4 & 7 | Lexical |
|
||||
|
||||
## Commands Reference
|
||||
|
||||
### TABLE.NAMESPACE.CREATE
|
||||
Create a namespace (required before creating tables).
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.NAMESPACE.CREATE <namespace>
|
||||
```
|
||||
|
||||
**Example:**
|
||||
```bash
|
||||
TABLE.NAMESPACE.CREATE mydb
|
||||
```
|
||||
|
||||
### TABLE.NAMESPACE.VIEW
|
||||
Display all namespace:table pairs, optionally filtered by namespace.
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.NAMESPACE.VIEW [<namespace>]
|
||||
```
|
||||
|
||||
**Examples:**
|
||||
```bash
|
||||
# View all tables across all namespaces
|
||||
TABLE.NAMESPACE.VIEW
|
||||
|
||||
# Returns (example):
|
||||
mydb:employees
|
||||
mydb:users
|
||||
testdb:products
|
||||
|
||||
# View tables in a specific namespace
|
||||
TABLE.NAMESPACE.VIEW mydb
|
||||
|
||||
# Returns (example):
|
||||
mydb:employees
|
||||
mydb:users
|
||||
```
|
||||
|
||||
**How it works:**
|
||||
1. Scans all `schema:*.*` keys to find tables
|
||||
2. Optionally filters by namespace if provided
|
||||
3. Returns sorted list of `namespace:table` pairs
|
||||
|
||||
### TABLE.SCHEMA.VIEW
|
||||
Display table schema with columns, types, and index status.
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.SCHEMA.VIEW <schema.table>
|
||||
```
|
||||
|
||||
**Example:**
|
||||
```bash
|
||||
TABLE.SCHEMA.VIEW mydb.people
|
||||
|
||||
# Returns:
|
||||
1) 1) "FNAME"
|
||||
2) "string"
|
||||
3) "true"
|
||||
2) 1) "LNAME"
|
||||
2) "string"
|
||||
3) "true"
|
||||
3) 1) "AGE"
|
||||
2) "integer"
|
||||
3) "false"
|
||||
4) 1) "SALARY"
|
||||
2) "float"
|
||||
3) "false"
|
||||
5) 1) "HIREDATE"
|
||||
2) "date"
|
||||
3) "true"
|
||||
```
|
||||
|
||||
**How it works:**
|
||||
1. Reads `schema:<table>` hash for columns and types
|
||||
2. Checks `idx:meta:<table>` set for indexed columns
|
||||
3. Returns `[column, type, indexed]` for each column
|
||||
|
||||
### TABLE.SCHEMA.CREATE
|
||||
Create a table with columns and optional index control.
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.SCHEMA.CREATE <schema.table> <col:type[:index]> [<col:type[:index]> ...]
|
||||
```
|
||||
|
||||
- `col` - column name
|
||||
- `type` - `string`, `integer`, `float`, or `date`
|
||||
- `index` - `true` or `false` (optional, defaults to `true`)
|
||||
|
||||
**Examples:**
|
||||
```bash
|
||||
# All columns indexed (backward compatible)
|
||||
TABLE.SCHEMA.CREATE mydb.people FNAME:string LNAME:string AGE:integer COUNTRY:string
|
||||
|
||||
# Explicit index control
|
||||
TABLE.SCHEMA.CREATE mydb.people FNAME:string:true LNAME:string:true AGE:integer:false COUNTRY:string:true
|
||||
|
||||
# With new types (float, date)
|
||||
TABLE.SCHEMA.CREATE mydb.employees EMPID:string:true NAME:string:true SALARY:float:false HIREDATE:date:true
|
||||
```
|
||||
|
||||
### TABLE.SCHEMA.ALTER
|
||||
Dynamically modify table structure and indexes.
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.SCHEMA.ALTER <schema.table> ADD COLUMN <col:type[:index]>
|
||||
TABLE.SCHEMA.ALTER <schema.table> ADD INDEX <col>
|
||||
TABLE.SCHEMA.ALTER <schema.table> DROP INDEX <col>
|
||||
```
|
||||
|
||||
**Important:** `ADD INDEX` automatically builds indexes for all existing rows!
|
||||
|
||||
**Examples:**
|
||||
```bash
|
||||
# Add new column
|
||||
TABLE.SCHEMA.ALTER mydb.people ADD COLUMN EMAIL:string:true
|
||||
TABLE.SCHEMA.ALTER mydb.people ADD COLUMN SALARY:float:false
|
||||
TABLE.SCHEMA.ALTER mydb.people ADD COLUMN BIRTHDATE:date:true
|
||||
|
||||
# Add index to existing column (builds for all existing rows!)
|
||||
TABLE.SCHEMA.ALTER mydb.people ADD INDEX AGE
|
||||
|
||||
# Remove index (keeps column, deletes all index keys)
|
||||
TABLE.SCHEMA.ALTER mydb.people DROP INDEX AGE
|
||||
```
|
||||
|
||||
### TABLE.INSERT
|
||||
Insert a new row with auto-generated ID.
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.INSERT <schema.table> <col>=<value> [<col>=<value> ...]
|
||||
```
|
||||
|
||||
**Examples:**
|
||||
```bash
|
||||
TABLE.INSERT mydb.people FNAME=John LNAME=Doe AGE=30 COUNTRY=USA
|
||||
# Returns: (integer) 1
|
||||
|
||||
TABLE.INSERT mydb.employees EMPID=E001 NAME=John SALARY=50000.50 HIREDATE=2020-01-15
|
||||
# Returns: (integer) 1
|
||||
```
|
||||
|
||||
### TABLE.SELECT
|
||||
Query rows with optional WHERE clause and comparison operators.
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.SELECT <schema.table> [WHERE <col><op><value> (AND|OR <col><op><value> ...)]
|
||||
```
|
||||
|
||||
**Operators:** `=`, `>`, `<`, `>=`, `<=`
|
||||
|
||||
**Important:** Equality (`=`) requires indexed columns. Comparison operators work on any column but scan all rows.
|
||||
|
||||
**Examples:**
|
||||
```bash
|
||||
# Select all rows
|
||||
TABLE.SELECT mydb.people
|
||||
|
||||
# Equality on indexed column (fast)
|
||||
TABLE.SELECT mydb.people WHERE COUNTRY=USA
|
||||
TABLE.SELECT mydb.people WHERE FNAME=John
|
||||
|
||||
# Comparison operators (scans all rows)
|
||||
TABLE.SELECT mydb.people WHERE AGE>30
|
||||
TABLE.SELECT mydb.people WHERE AGE>=25
|
||||
TABLE.SELECT mydb.people WHERE AGE<40
|
||||
|
||||
# Float comparisons
|
||||
TABLE.SELECT mydb.employees WHERE SALARY>50000.00
|
||||
TABLE.SELECT mydb.employees WHERE SALARY<=60000.00
|
||||
|
||||
# Date comparisons
|
||||
TABLE.SELECT mydb.employees WHERE HIREDATE>2020-01-01
|
||||
TABLE.SELECT mydb.employees WHERE HIREDATE>=2020-01-01 AND HIREDATE<=2020-12-31
|
||||
|
||||
# Combined conditions
|
||||
TABLE.SELECT mydb.people WHERE AGE>25 AND COUNTRY=USA
|
||||
TABLE.SELECT mydb.people WHERE COUNTRY=USA OR COUNTRY=Canada
|
||||
TABLE.SELECT mydb.people WHERE AGE>=30 OR COUNTRY=France
|
||||
```
|
||||
|
||||
### TABLE.UPDATE
|
||||
Update rows matching WHERE clause.
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.UPDATE <schema.table> WHERE <cond> (AND|OR <cond> ...) SET <col>=<value> [<col>=<value> ...]
|
||||
```
|
||||
|
||||
**Examples:**
|
||||
```bash
|
||||
TABLE.UPDATE mydb.people WHERE FNAME=John SET AGE=31
|
||||
TABLE.UPDATE mydb.people WHERE AGE=30 AND COUNTRY=Canada SET COUNTRY=France
|
||||
TABLE.UPDATE mydb.employees WHERE EMPID=E001 SET SALARY=52000.75 HIREDATE=2020-02-01
|
||||
```
|
||||
|
||||
### TABLE.DELETE
|
||||
Delete rows matching WHERE clause.
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.DELETE <schema.table> [WHERE <cond> (AND|OR <cond> ...)]
|
||||
```
|
||||
|
||||
**Examples:**
|
||||
```bash
|
||||
TABLE.DELETE mydb.people WHERE COUNTRY=France
|
||||
TABLE.DELETE mydb.people WHERE AGE>40
|
||||
TABLE.DELETE mydb.people WHERE FNAME=Jane OR FNAME=Bob
|
||||
```
|
||||
|
||||
### TABLE.DROP
|
||||
Drop a table (removes table schema, all rows, indexes, and metadata).
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.DROP <schema.table> FORCE
|
||||
```
|
||||
|
||||
**Important:** The `FORCE` parameter is required to confirm the irreversible deletion. Without it, the command will fail with a warning message.
|
||||
|
||||
**Examples:**
|
||||
```bash
|
||||
# Without FORCE - will fail with warning
|
||||
TABLE.DROP mydb.people
|
||||
# Returns: (error) ERR This operation is irreversible, use FORCE parameter to remove the table
|
||||
|
||||
# With FORCE - will succeed
|
||||
TABLE.DROP mydb.people FORCE
|
||||
# Returns: OK
|
||||
```
|
||||
|
||||
### TABLE.HELP
|
||||
Display help text.
|
||||
|
||||
**Syntax:**
|
||||
```
|
||||
TABLE.HELP
|
||||
```
|
||||
|
||||
## Complete Example
|
||||
|
||||
```bash
|
||||
FLUSHALL
|
||||
|
||||
# 1. Create namespace
|
||||
TABLE.NAMESPACE.CREATE mydb
|
||||
|
||||
# 2. Create table with explicit index control and new types
|
||||
TABLE.SCHEMA.CREATE mydb.employees EMPID:string:true FNAME:string:true LNAME:string:true AGE:integer:false SALARY:float:false DEPT:string:true HIREDATE:date:true
|
||||
|
||||
# 3. View all tables in all namespaces
|
||||
TABLE.NAMESPACE.VIEW
|
||||
|
||||
# 4. View tables in specific namespace
|
||||
TABLE.NAMESPACE.VIEW mydb
|
||||
|
||||
# 5. View table schema
|
||||
TABLE.SCHEMA.VIEW mydb.employees
|
||||
|
||||
# 6. Insert data
|
||||
TABLE.INSERT mydb.employees EMPID=E001 FNAME=John LNAME=Doe AGE=30 SALARY=50000.50 DEPT=Engineering HIREDATE=2020-01-15
|
||||
TABLE.INSERT mydb.employees EMPID=E002 FNAME=Jane LNAME=Smith AGE=28 SALARY=55000.75 DEPT=Marketing HIREDATE=2021-03-20
|
||||
TABLE.INSERT mydb.employees EMPID=E003 FNAME=Bob LNAME=Johnson AGE=35 SALARY=60000.00 DEPT=Engineering HIREDATE=2019-06-10
|
||||
TABLE.INSERT mydb.employees EMPID=E004 FNAME=Alice LNAME=Williams AGE=32 SALARY=58000.25 DEPT=Sales HIREDATE=2020-11-05
|
||||
|
||||
# 7. Fast indexed searches (=)
|
||||
TABLE.SELECT mydb.employees WHERE DEPT=Engineering
|
||||
TABLE.SELECT mydb.employees WHERE FNAME=Jane
|
||||
TABLE.SELECT mydb.employees WHERE HIREDATE=2020-01-15
|
||||
|
||||
# 8. Comparison searches (scans all rows)
|
||||
TABLE.SELECT mydb.employees WHERE AGE>30
|
||||
TABLE.SELECT mydb.employees WHERE SALARY>=55000.00
|
||||
TABLE.SELECT mydb.employees WHERE HIREDATE>2020-01-01
|
||||
|
||||
# 9. Date range queries
|
||||
TABLE.SELECT mydb.employees WHERE HIREDATE>=2020-01-01 AND HIREDATE<=2020-12-31
|
||||
|
||||
# 10. Float comparisons
|
||||
TABLE.SELECT mydb.employees WHERE SALARY>55000.00
|
||||
TABLE.SELECT mydb.employees WHERE SALARY<=58000.00
|
||||
|
||||
# 11. Combined conditions
|
||||
TABLE.SELECT mydb.employees WHERE AGE>28 AND DEPT=Engineering
|
||||
TABLE.SELECT mydb.employees WHERE SALARY>=55000.00 OR DEPT=Sales
|
||||
|
||||
# 12. Add index to existing column (builds for all 4 rows!)
|
||||
TABLE.SCHEMA.ALTER mydb.employees ADD INDEX AGE
|
||||
|
||||
# 13. View updated table schema
|
||||
TABLE.SCHEMA.VIEW mydb.employees
|
||||
# Now AGE shows indexed=true
|
||||
|
||||
# 14. Now equality search on AGE works (fast)
|
||||
TABLE.SELECT mydb.employees WHERE AGE=30
|
||||
|
||||
# 15. Update with new types
|
||||
TABLE.UPDATE mydb.employees WHERE EMPID=E001 SET SALARY=52000.75 AGE=31 HIREDATE=2020-02-01
|
||||
|
||||
# 16. Delete rows
|
||||
TABLE.DELETE mydb.employees WHERE AGE>35
|
||||
|
||||
# 17. Add new columns
|
||||
TABLE.SCHEMA.ALTER mydb.employees ADD COLUMN CITY:string:true
|
||||
TABLE.SCHEMA.ALTER mydb.employees ADD COLUMN BONUS:float:false
|
||||
TABLE.SCHEMA.ALTER mydb.employees ADD COLUMN REVIEWDATE:date:false
|
||||
|
||||
# 18. Remove index
|
||||
TABLE.SCHEMA.ALTER mydb.employees DROP INDEX LNAME
|
||||
|
||||
# 19. Drop table (requires FORCE parameter)
|
||||
TABLE.DROP mydb.employees FORCE
|
||||
```
|
||||
|
||||
## Data Model
|
||||
|
||||
The module uses the following Redis keys:
|
||||
|
||||
```
|
||||
schema:<namespace> - Namespace marker (string "1")
|
||||
schema:<namespace>.<table> - Table schema hash (col => type)
|
||||
idx:meta:<namespace>.<table> - Index metadata set (indexed column names)
|
||||
<namespace>.<table>:<id> - Row hash
|
||||
table:<namespace>.<table>:id - Auto-increment counter
|
||||
rows:<namespace>.<table> - Set of all row IDs
|
||||
idx:<namespace>.<table>:<col>:<value> - Index set (only for indexed columns)
|
||||
```
|
||||
|
||||
## Inspecting Underlying Keys
|
||||
|
||||
```bash
|
||||
# Namespace marker
|
||||
GET schema:mydb
|
||||
# Returns: "1"
|
||||
|
||||
# Table schema
|
||||
HGETALL schema:mydb.employees
|
||||
# Returns: EMPID => string, FNAME => string, ...
|
||||
|
||||
# Index metadata
|
||||
SMEMBERS idx:meta:mydb.employees
|
||||
# Returns: EMPID, FNAME, LNAME, DEPT, HIREDATE (indexed columns)
|
||||
|
||||
# Row IDs
|
||||
SMEMBERS rows:mydb.employees
|
||||
# Returns: 1, 2, 3, 4
|
||||
|
||||
# Specific row
|
||||
HGETALL mydb.employees:1
|
||||
# Returns: EMPID => E001, FNAME => John, ...
|
||||
|
||||
# Index keys
|
||||
KEYS idx:mydb.employees:DEPT:*
|
||||
# Returns: idx:mydb.employees:DEPT:Engineering, idx:mydb.employees:DEPT:Marketing, ...
|
||||
|
||||
SMEMBERS idx:mydb.employees:DEPT:Engineering
|
||||
# Returns: 1, 3 (row IDs)
|
||||
```
|
||||
|
||||
## Performance Considerations
|
||||
|
||||
### Indexed Columns (= operator)
|
||||
- **Fast** - O(1) lookup via Redis sets
|
||||
- Use for frequently queried columns
|
||||
- Adds storage overhead (one set per unique value)
|
||||
|
||||
### Non-Indexed Columns (comparison operators)
|
||||
- **Slow** - O(N) full table scan
|
||||
- Use for infrequent queries or small tables
|
||||
- No storage overhead
|
||||
|
||||
### Index Building
|
||||
- `ADD INDEX` scans all existing rows: O(N)
|
||||
- Do this during low-traffic periods for large tables
|
||||
|
||||
### Best Practices
|
||||
1. **Index selective columns** - High cardinality, frequently queried
|
||||
2. **Don't index everything** - Indexes consume memory and slow writes
|
||||
3. **Use comparison operators sparingly** - They scan all rows
|
||||
4. **Add indexes dynamically** - Use TABLE.ALTER based on query patterns
|
||||
5. **Drop unused indexes** - Free up memory
|
||||
|
||||
## Testing
|
||||
|
||||
The module includes a comprehensive test suite with 86 tests covering all functionality:
|
||||
|
||||
```bash
|
||||
# Run all tests (recommended)
|
||||
make test
|
||||
|
||||
# Or run tests manually
|
||||
cd tests
|
||||
./run_tests.sh
|
||||
```
|
||||
|
||||
### Test Coverage
|
||||
- ✅ Namespace management (4 tests)
|
||||
- ✅ Table creation and schema operations (9 tests)
|
||||
- ✅ Data insertion with type validation (9 tests)
|
||||
- ✅ Data selection and querying (3 tests)
|
||||
- ✅ Comparison operators (8 tests)
|
||||
- ✅ Logical operators (2 tests)
|
||||
- ✅ Table alteration (7 tests)
|
||||
- ✅ Data updates (5 tests)
|
||||
- ✅ Data deletion (3 tests)
|
||||
- ✅ Table dropping (6 tests)
|
||||
- ✅ Edge cases and error handling (6 tests)
|
||||
- ✅ Help command (3 tests)
|
||||
- ✅ Index maintenance (3 tests)
|
||||
- ✅ Complex scenarios (6 tests)
|
||||
|
||||
**All 86 tests pass successfully!**
|
||||
|
||||
Test new features manually:
|
||||
```bash
|
||||
# Test float
|
||||
TABLE.SCHEMA.CREATE test.data VALUE:float:true
|
||||
TABLE.INSERT test.data VALUE=123.45
|
||||
TABLE.SELECT test.data WHERE VALUE>100.00
|
||||
|
||||
# Test date
|
||||
TABLE.SCHEMA.CREATE test.events DATE:date:true
|
||||
TABLE.INSERT test.events DATE=2024-01-15
|
||||
TABLE.SELECT test.events WHERE DATE>=2024-01-01
|
||||
|
||||
# Test table schema view
|
||||
TABLE.SCHEMA.VIEW test.data
|
||||
|
||||
# Test index building
|
||||
TABLE.SCHEMA.CREATE test.users AGE:integer:false
|
||||
TABLE.INSERT test.users AGE=30
|
||||
TABLE.INSERT test.users AGE=25
|
||||
TABLE.SCHEMA.ALTER test.users ADD INDEX AGE
|
||||
TABLE.SELECT test.users WHERE AGE=30 # Now works!
|
||||
```
|
||||
|
||||
## Error Messages
|
||||
|
||||
- `ERR namespace does not exist` - Create namespace first with TABLE.NAMESPACE.CREATE
|
||||
- `ERR table schema does not exist` - Table doesn't exist
|
||||
- `ERR table schema already exists` - Table name conflict
|
||||
- `ERR invalid column or type` - Column doesn't exist or type mismatch
|
||||
- `ERR search cannot be done on non-indexed column` - Use = only on indexed columns
|
||||
- `ERR column does not exist` - Column not in table schema (when adding index)
|
||||
- `ERR format: <col:type> or <col:type:index>` - Invalid CREATE syntax
|
||||
- `ERR index must be 'true' or 'false'` - Invalid index value
|
||||
|
||||
## Limitations
|
||||
|
||||
- Maximum 1000 rows per WHERE clause (array limit in filter functions)
|
||||
- Comparison operators require full table scan
|
||||
- No compound indexes (index per column only)
|
||||
- No LIKE/pattern matching
|
||||
- No JOIN operations
|
||||
- No transactions
|
||||
- Date format must be YYYY-MM-DD (no time component)
|
||||
- Float stored as string (precision limited by string conversion)
|
||||
|
||||
## Migration from V1
|
||||
|
||||
V1 tables (all columns auto-indexed) work with the unified module:
|
||||
- Old syntax (without `:index`) defaults to `indexed=true`
|
||||
- All V1 commands work unchanged
|
||||
- Can use TABLE.ALTER to drop indexes on V1 tables
|
||||
|
||||
## Summary
|
||||
|
||||
The unified Redis Table Module provides:
|
||||
- ✅ **Full CRUD operations** - CREATE, INSERT, SELECT, UPDATE, DELETE, DROP
|
||||
- ✅ **Explicit index control** - Define which columns are indexed
|
||||
- ✅ **4 data types** - string, integer, float, date
|
||||
- ✅ **Comparison operators** - =, >, <, >=, <=
|
||||
- ✅ **Logical operators** - AND, OR
|
||||
- ✅ **Dynamic table schema** - Add/remove columns and indexes
|
||||
- ✅ **Table schema introspection** - TABLE.SCHEMA.VIEW
|
||||
- ✅ **Auto-index building** - ADD INDEX creates indexes for existing data
|
||||
- ✅ **Auto-index cleanup** - DELETE/UPDATE maintain indexes automatically
|
||||
- ✅ **Backward compatible** - V1 syntax still works
|
||||
|
||||
Use this module when you need SQL-like tables in Redis with fine-grained control over indexing and support for multiple data types.
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,938 @@
|
|||
/*
|
||||
* File: redis_table.c
|
||||
* Author: Raphael Drai
|
||||
* Email: raphael.drai@gmail.com
|
||||
* Date: October 3, 2025
|
||||
* Description: This program is a Redis module that implements SQL-like tables
|
||||
* with full CRUD operations, explicit index control, comparison operators,
|
||||
* and support for multiple data types.
|
||||
*/
|
||||
|
||||
#include "redismodule.h"
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
static inline RedisModuleString *fmt(RedisModuleCtx *ctx, const char *fmt, RedisModuleString *a) {
|
||||
return RedisModule_CreateStringPrintf(ctx, fmt, RedisModule_StringPtrLen(a, NULL));
|
||||
}
|
||||
static inline RedisModuleString *fmt2(RedisModuleCtx *ctx, const char *fmt, RedisModuleString *a, RedisModuleString *b) {
|
||||
return RedisModule_CreateStringPrintf(ctx, fmt, RedisModule_StringPtrLen(a, NULL), RedisModule_StringPtrLen(b, NULL));
|
||||
}
|
||||
static inline RedisModuleString *fmt3(RedisModuleCtx *ctx, const char *fmt, RedisModuleString *a, RedisModuleString *b, RedisModuleString *c) {
|
||||
return RedisModule_CreateStringPrintf(ctx, fmt,
|
||||
RedisModule_StringPtrLen(a, NULL),
|
||||
RedisModule_StringPtrLen(b, NULL),
|
||||
RedisModule_StringPtrLen(c, NULL));
|
||||
}
|
||||
|
||||
// Split "col=value" or "col>value" etc into (col, op, value)
|
||||
static int split_condition(RedisModuleCtx *ctx, RedisModuleString *in,
|
||||
RedisModuleString **colOut, char *opOut, RedisModuleString **valOut) {
|
||||
size_t len; const char *s = RedisModule_StringPtrLen(in, &len);
|
||||
const char *op = NULL;
|
||||
size_t oplen = 0;
|
||||
|
||||
// Look for operators: >=, <=, >, <, =
|
||||
for (size_t i = 0; i < len - 1; i++) {
|
||||
if (s[i] == '>' && s[i+1] == '=') { op = &s[i]; oplen = 2; break; }
|
||||
if (s[i] == '<' && s[i+1] == '=') { op = &s[i]; oplen = 2; break; }
|
||||
}
|
||||
if (!op) {
|
||||
for (size_t i = 0; i < len; i++) {
|
||||
if (s[i] == '=' || s[i] == '>' || s[i] == '<') { op = &s[i]; oplen = 1; break; }
|
||||
}
|
||||
}
|
||||
|
||||
if (!op || op == s || (size_t)(op - s + oplen) >= len) return REDISMODULE_ERR;
|
||||
|
||||
*colOut = RedisModule_CreateString(ctx, s, (size_t)(op - s));
|
||||
if (oplen == 2) {
|
||||
opOut[0] = op[0]; opOut[1] = op[1]; opOut[2] = '\0';
|
||||
} else {
|
||||
opOut[0] = op[0]; opOut[1] = '\0';
|
||||
}
|
||||
*valOut = RedisModule_CreateString(ctx, op + oplen, len - (size_t)(op - s) - oplen);
|
||||
return REDISMODULE_OK;
|
||||
}
|
||||
|
||||
// Check if column is indexed
|
||||
static int is_column_indexed(RedisModuleCtx *ctx, RedisModuleString *table, RedisModuleString *col) {
|
||||
RedisModule_AutoMemory(ctx);
|
||||
RedisModuleString *metaKey = fmt(ctx, "idx:meta:%s", table);
|
||||
RedisModuleCallReply *r = RedisModule_Call(ctx, "SISMEMBER", "ss", metaKey, col);
|
||||
return (r && RedisModule_CallReplyType(r) == REDISMODULE_REPLY_INTEGER &&
|
||||
RedisModule_CallReplyInteger(r) == 1) ? 1 : 0;
|
||||
}
|
||||
|
||||
// Compare two values based on operator and type
|
||||
static int compare_values(const char *v1, const char *v2, const char *op, const char *type) {
|
||||
if (strcmp(type, "integer") == 0) {
|
||||
long long n1 = atoll(v1);
|
||||
long long n2 = atoll(v2);
|
||||
if (strcmp(op, "=") == 0) return n1 == n2;
|
||||
if (strcmp(op, ">") == 0) return n1 > n2;
|
||||
if (strcmp(op, "<") == 0) return n1 < n2;
|
||||
if (strcmp(op, ">=") == 0) return n1 >= n2;
|
||||
if (strcmp(op, "<=") == 0) return n1 <= n2;
|
||||
} else if (strcmp(type, "float") == 0) {
|
||||
double d1 = atof(v1);
|
||||
double d2 = atof(v2);
|
||||
if (strcmp(op, "=") == 0) return d1 == d2;
|
||||
if (strcmp(op, ">") == 0) return d1 > d2;
|
||||
if (strcmp(op, "<") == 0) return d1 < d2;
|
||||
if (strcmp(op, ">=") == 0) return d1 >= d2;
|
||||
if (strcmp(op, "<=") == 0) return d1 <= d2;
|
||||
} else if (strcmp(type, "date") == 0) {
|
||||
// Date comparison as string (YYYY-MM-DD format sorts correctly)
|
||||
int cmp = strcmp(v1, v2);
|
||||
if (strcmp(op, "=") == 0) return cmp == 0;
|
||||
if (strcmp(op, ">") == 0) return cmp > 0;
|
||||
if (strcmp(op, "<") == 0) return cmp < 0;
|
||||
if (strcmp(op, ">=") == 0) return cmp >= 0;
|
||||
if (strcmp(op, "<=") == 0) return cmp <= 0;
|
||||
} else {
|
||||
// String comparison
|
||||
int cmp = strcmp(v1, v2);
|
||||
if (strcmp(op, "=") == 0) return cmp == 0;
|
||||
if (strcmp(op, ">") == 0) return cmp > 0;
|
||||
if (strcmp(op, "<") == 0) return cmp < 0;
|
||||
if (strcmp(op, ">=") == 0) return cmp >= 0;
|
||||
if (strcmp(op, "<=") == 0) return cmp <= 0;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ensure_schema_exists(RedisModuleCtx *ctx, RedisModuleString *schemaName) {
|
||||
RedisModule_AutoMemory(ctx);
|
||||
RedisModuleKey *k = RedisModule_OpenKey(ctx, fmt(ctx, "schema:%s", schemaName), REDISMODULE_READ);
|
||||
return RedisModule_KeyType(k) != REDISMODULE_KEYTYPE_EMPTY ? REDISMODULE_OK : REDISMODULE_ERR;
|
||||
}
|
||||
|
||||
static int ensure_table_exists(RedisModuleCtx *ctx, RedisModuleString *fullTableName) {
|
||||
RedisModule_AutoMemory(ctx);
|
||||
RedisModuleKey *k = RedisModule_OpenKey(ctx, fmt(ctx, "schema:%s", fullTableName), REDISMODULE_READ);
|
||||
return RedisModule_KeyType(k) == REDISMODULE_KEYTYPE_HASH ? REDISMODULE_OK : REDISMODULE_ERR;
|
||||
}
|
||||
|
||||
static RedisModuleString* extract_schema(RedisModuleCtx *ctx, RedisModuleString *fullTable) {
|
||||
size_t len; const char *s = RedisModule_StringPtrLen(fullTable, &len);
|
||||
const char *dot = memchr(s, '.', len);
|
||||
if (!dot) return NULL;
|
||||
return RedisModule_CreateString(ctx, s, (size_t)(dot - s));
|
||||
}
|
||||
|
||||
static int validate_and_typecheck(RedisModuleCtx *ctx, RedisModuleString *fullTableName,
|
||||
RedisModuleString *col, RedisModuleString *val) {
|
||||
RedisModule_AutoMemory(ctx);
|
||||
RedisModuleKey *schemaKey = RedisModule_OpenKey(ctx, fmt(ctx, "schema:%s", fullTableName), REDISMODULE_READ);
|
||||
if (RedisModule_KeyType(schemaKey) != REDISMODULE_KEYTYPE_HASH) return REDISMODULE_ERR;
|
||||
RedisModuleString *typeStr = NULL;
|
||||
if (RedisModule_HashGet(schemaKey, REDISMODULE_HASH_NONE, col, &typeStr, NULL) != REDISMODULE_OK || !typeStr) return REDISMODULE_ERR;
|
||||
size_t tlen; const char *t = RedisModule_StringPtrLen(typeStr, &tlen);
|
||||
|
||||
if (tlen == 7 && strncasecmp(t, "integer", 7) == 0) {
|
||||
// Validate integer
|
||||
size_t vlen; const char *vs = RedisModule_StringPtrLen(val, &vlen);
|
||||
if (vlen == 0) return REDISMODULE_ERR;
|
||||
size_t i = 0; if (vs[0] == '-' || vs[0] == '+') i = 1; if (i >= vlen) return REDISMODULE_ERR;
|
||||
for (; i < vlen; i++) if (vs[i] < '0' || vs[i] > '9') return REDISMODULE_ERR;
|
||||
} else if (tlen == 5 && strncasecmp(t, "float", 5) == 0) {
|
||||
// Validate float (simple check for digits, optional decimal point)
|
||||
size_t vlen; const char *vs = RedisModule_StringPtrLen(val, &vlen);
|
||||
if (vlen == 0) return REDISMODULE_ERR;
|
||||
int hasDot = 0;
|
||||
size_t i = 0; if (vs[0] == '-' || vs[0] == '+') i = 1; if (i >= vlen) return REDISMODULE_ERR;
|
||||
for (; i < vlen; i++) {
|
||||
if (vs[i] == '.') { if (hasDot) return REDISMODULE_ERR; hasDot = 1; }
|
||||
else if (vs[i] < '0' || vs[i] > '9') return REDISMODULE_ERR;
|
||||
}
|
||||
} else if (tlen == 4 && strncasecmp(t, "date", 4) == 0) {
|
||||
// Validate date format YYYY-MM-DD
|
||||
size_t vlen; const char *vs = RedisModule_StringPtrLen(val, &vlen);
|
||||
if (vlen != 10) return REDISMODULE_ERR;
|
||||
if (vs[4] != '-' || vs[7] != '-') return REDISMODULE_ERR;
|
||||
for (int i = 0; i < 10; i++) {
|
||||
if (i == 4 || i == 7) continue;
|
||||
if (vs[i] < '0' || vs[i] > '9') return REDISMODULE_ERR;
|
||||
}
|
||||
}
|
||||
return REDISMODULE_OK;
|
||||
}
|
||||
|
||||
/* ================== TABLE.NAMESPACE.CREATE <namespace> ================== */
|
||||
static int TableNamespaceCreateCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc != 2) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
RedisModuleKey *k = RedisModule_OpenKey(ctx, fmt(ctx, "schema:%s", argv[1]), REDISMODULE_WRITE);
|
||||
if (RedisModule_KeyType(k) != REDISMODULE_KEYTYPE_EMPTY)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR namespace already exists");
|
||||
RedisModule_StringSet(k, RedisModule_CreateString(ctx, "1", 1));
|
||||
return RedisModule_ReplyWithSimpleString(ctx, "OK");
|
||||
}
|
||||
|
||||
/* ================== TABLE.NAMESPACE.VIEW [<namespace>] ================== */
|
||||
static int TableNamespaceViewCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc != 1 && argc != 2) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
|
||||
const char *filter_namespace = NULL;
|
||||
size_t filter_len = 0;
|
||||
if (argc == 2) {
|
||||
filter_namespace = RedisModule_StringPtrLen(argv[1], &filter_len);
|
||||
}
|
||||
|
||||
// Scan for all schema keys (pattern: schema:*.*)
|
||||
RedisModuleCallReply *keys = RedisModule_Call(ctx, "KEYS", "c", "schema:*.*");
|
||||
if (!keys || RedisModule_CallReplyType(keys) != REDISMODULE_REPLY_ARRAY) {
|
||||
return RedisModule_ReplyWithArray(ctx, 0);
|
||||
}
|
||||
|
||||
size_t n = RedisModule_CallReplyLength(keys);
|
||||
|
||||
// If no keys found, return empty array
|
||||
if (n == 0) {
|
||||
return RedisModule_ReplyWithArray(ctx, 0);
|
||||
}
|
||||
|
||||
// Collect namespace:table pairs
|
||||
typedef struct {
|
||||
char namespace[256];
|
||||
char table[256];
|
||||
} TableEntry;
|
||||
|
||||
TableEntry *entries = RedisModule_Alloc(sizeof(TableEntry) * n);
|
||||
size_t count = 0;
|
||||
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
RedisModuleCallReply *keyReply = RedisModule_CallReplyArrayElement(keys, i);
|
||||
size_t keylen;
|
||||
const char *keystr = RedisModule_CallReplyStringPtr(keyReply, &keylen);
|
||||
|
||||
// Skip if not in format "schema:namespace.table"
|
||||
if (keylen < 8 || strncmp(keystr, "schema:", 7) != 0) continue;
|
||||
|
||||
const char *fullname = keystr + 7; // Skip "schema:"
|
||||
size_t fullname_len = keylen - 7;
|
||||
|
||||
// Find the dot separator
|
||||
const char *dot = memchr(fullname, '.', fullname_len);
|
||||
if (!dot) continue; // Not a table (just a namespace marker)
|
||||
|
||||
size_t ns_len = (size_t)(dot - fullname);
|
||||
size_t tbl_len = fullname_len - ns_len - 1;
|
||||
|
||||
// Apply filter if provided
|
||||
if (filter_namespace && (ns_len != filter_len || strncmp(fullname, filter_namespace, ns_len) != 0)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
// Store entry
|
||||
if (ns_len < 256 && tbl_len < 256) {
|
||||
strncpy(entries[count].namespace, fullname, ns_len);
|
||||
entries[count].namespace[ns_len] = '\0';
|
||||
strncpy(entries[count].table, dot + 1, tbl_len);
|
||||
entries[count].table[tbl_len] = '\0';
|
||||
count++;
|
||||
}
|
||||
}
|
||||
|
||||
// Simple bubble sort by namespace (then by table)
|
||||
if (count > 1) {
|
||||
for (size_t i = 0; i < count - 1; i++) {
|
||||
for (size_t j = 0; j < count - i - 1; j++) {
|
||||
int cmp = strcmp(entries[j].namespace, entries[j+1].namespace);
|
||||
if (cmp > 0 || (cmp == 0 && strcmp(entries[j].table, entries[j+1].table) > 0)) {
|
||||
TableEntry temp = entries[j];
|
||||
entries[j] = entries[j+1];
|
||||
entries[j+1] = temp;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Reply with array of "namespace:table" strings
|
||||
RedisModule_ReplyWithArray(ctx, count);
|
||||
for (size_t i = 0; i < count; i++) {
|
||||
RedisModuleString *result = RedisModule_CreateStringPrintf(ctx, "%s:%s", entries[i].namespace, entries[i].table);
|
||||
RedisModule_ReplyWithString(ctx, result);
|
||||
}
|
||||
|
||||
RedisModule_Free(entries);
|
||||
return REDISMODULE_OK;
|
||||
}
|
||||
|
||||
/* ================== TABLE.SCHEMA.VIEW <namespace.table> ================== */
|
||||
static int TableSchemaViewCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc != 2) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
|
||||
if (ensure_table_exists(ctx, argv[1]) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR table schema does not exist");
|
||||
|
||||
// Get all columns from table schema
|
||||
RedisModuleCallReply *fields = RedisModule_Call(ctx, "HGETALL", "s", fmt(ctx, "schema:%s", argv[1]));
|
||||
if (!fields || RedisModule_CallReplyType(fields) != REDISMODULE_REPLY_ARRAY) {
|
||||
return RedisModule_ReplyWithArray(ctx, 0);
|
||||
}
|
||||
|
||||
size_t n = RedisModule_CallReplyLength(fields);
|
||||
size_t numCols = n / 2;
|
||||
|
||||
// Reply format: array of [column, type, indexed]
|
||||
RedisModule_ReplyWithArray(ctx, numCols);
|
||||
|
||||
for (size_t i = 0; i < n; i += 2) {
|
||||
RedisModuleCallReply *colReply = RedisModule_CallReplyArrayElement(fields, i);
|
||||
RedisModuleCallReply *typeReply = RedisModule_CallReplyArrayElement(fields, i + 1);
|
||||
|
||||
RedisModuleString *col = RedisModule_CreateStringFromCallReply(colReply);
|
||||
RedisModuleString *type = RedisModule_CreateStringFromCallReply(typeReply);
|
||||
|
||||
// Check if indexed
|
||||
int indexed = is_column_indexed(ctx, argv[1], col);
|
||||
|
||||
// Reply with array: [column, type, indexed]
|
||||
RedisModule_ReplyWithArray(ctx, 3);
|
||||
RedisModule_ReplyWithString(ctx, col);
|
||||
RedisModule_ReplyWithString(ctx, type);
|
||||
RedisModule_ReplyWithSimpleString(ctx, indexed ? "true" : "false");
|
||||
}
|
||||
|
||||
return REDISMODULE_OK;
|
||||
}
|
||||
|
||||
/* ================== TABLE.SCHEMA.CREATE <namespace.table> <col:type:index> ... ================== */
|
||||
static int TableSchemaCreateCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc < 3) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
|
||||
RedisModuleString *schema = extract_schema(ctx, argv[1]);
|
||||
if (!schema) return RedisModule_ReplyWithError(ctx, "ERR table name must be namespace.table");
|
||||
if (ensure_schema_exists(ctx, schema) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR namespace does not exist");
|
||||
|
||||
RedisModuleKey *schemaKey = RedisModule_OpenKey(ctx, fmt(ctx, "schema:%s", argv[1]), REDISMODULE_WRITE);
|
||||
if (RedisModule_KeyType(schemaKey) != REDISMODULE_KEYTYPE_EMPTY)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR table schema already exists");
|
||||
|
||||
RedisModuleString *metaKey = fmt(ctx, "idx:meta:%s", argv[1]);
|
||||
|
||||
// Parse col:type:index (index is optional, defaults to true for backward compat)
|
||||
for (int i = 2; i < argc; i++) {
|
||||
size_t len; const char *s = RedisModule_StringPtrLen(argv[i], &len);
|
||||
const char *colon1 = memchr(s, ':', len);
|
||||
if (!colon1 || colon1 == s)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR format: <col:type> or <col:type:index>");
|
||||
|
||||
size_t col_len = (size_t)(colon1 - s);
|
||||
const char *colon2 = memchr(colon1 + 1, ':', len - col_len - 1);
|
||||
|
||||
RedisModuleString *col = RedisModule_CreateString(ctx, s, col_len);
|
||||
RedisModuleString *typ;
|
||||
int indexed = 1; // default true
|
||||
|
||||
if (colon2) {
|
||||
// col:type:index format
|
||||
typ = RedisModule_CreateString(ctx, colon1 + 1, (size_t)(colon2 - colon1 - 1));
|
||||
const char *idx_str = colon2 + 1;
|
||||
size_t idx_len = len - (size_t)(colon2 - s) - 1;
|
||||
if (idx_len == 5 && strncasecmp(idx_str, "false", 5) == 0) indexed = 0;
|
||||
else if (idx_len == 4 && strncasecmp(idx_str, "true", 4) == 0) indexed = 1;
|
||||
else return RedisModule_ReplyWithError(ctx, "ERR index must be 'true' or 'false'");
|
||||
} else {
|
||||
// col:type format (backward compat - index defaults to true)
|
||||
typ = RedisModule_CreateString(ctx, colon1 + 1, len - col_len - 1);
|
||||
}
|
||||
|
||||
RedisModule_HashSet(schemaKey, REDISMODULE_HASH_NONE, col, typ, NULL);
|
||||
if (indexed) {
|
||||
RedisModule_Call(ctx, "SADD", "ss", metaKey, col);
|
||||
}
|
||||
}
|
||||
return RedisModule_ReplyWithSimpleString(ctx, "OK");
|
||||
}
|
||||
|
||||
/* ================== TABLE.SCHEMA.ALTER <namespace.table> ADD/DROP COLUMN/INDEX ... ================== */
|
||||
static int TableSchemaAlterCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc < 4) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
|
||||
if (ensure_table_exists(ctx, argv[1]) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR table schema does not exist");
|
||||
|
||||
size_t oplen; const char *op = RedisModule_StringPtrLen(argv[2], &oplen);
|
||||
size_t targetlen; const char *target = RedisModule_StringPtrLen(argv[3], &targetlen);
|
||||
|
||||
RedisModuleKey *schemaKey = RedisModule_OpenKey(ctx, fmt(ctx, "schema:%s", argv[1]), REDISMODULE_WRITE);
|
||||
RedisModuleString *metaKey = fmt(ctx, "idx:meta:%s", argv[1]);
|
||||
|
||||
if (oplen == 3 && strncasecmp(op, "ADD", 3) == 0) {
|
||||
if (targetlen == 6 && strncasecmp(target, "COLUMN", 6) == 0) {
|
||||
// ADD COLUMN col:type[:index]
|
||||
if (argc != 5) return RedisModule_ReplyWithError(ctx, "ERR ADD COLUMN requires col:type[:index]");
|
||||
size_t len; const char *s = RedisModule_StringPtrLen(argv[4], &len);
|
||||
const char *colon1 = memchr(s, ':', len);
|
||||
if (!colon1) return RedisModule_ReplyWithError(ctx, "ERR format: col:type[:index]");
|
||||
|
||||
RedisModuleString *col = RedisModule_CreateString(ctx, s, (size_t)(colon1 - s));
|
||||
const char *colon2 = memchr(colon1 + 1, ':', len - (size_t)(colon1 - s) - 1);
|
||||
RedisModuleString *typ;
|
||||
int indexed = 1;
|
||||
|
||||
if (colon2) {
|
||||
typ = RedisModule_CreateString(ctx, colon1 + 1, (size_t)(colon2 - colon1 - 1));
|
||||
const char *idx = colon2 + 1;
|
||||
if (strncasecmp(idx, "false", 5) == 0) indexed = 0;
|
||||
} else {
|
||||
typ = RedisModule_CreateString(ctx, colon1 + 1, len - (size_t)(colon1 - s) - 1);
|
||||
}
|
||||
|
||||
RedisModule_HashSet(schemaKey, REDISMODULE_HASH_NONE, col, typ, NULL);
|
||||
if (indexed) RedisModule_Call(ctx, "SADD", "ss", metaKey, col);
|
||||
return RedisModule_ReplyWithSimpleString(ctx, "OK");
|
||||
|
||||
} else if (targetlen == 5 && strncasecmp(target, "INDEX", 5) == 0) {
|
||||
// ADD INDEX col - build index for existing data
|
||||
if (argc != 5) return RedisModule_ReplyWithError(ctx, "ERR ADD INDEX requires column name");
|
||||
RedisModuleString *col = argv[4];
|
||||
|
||||
// Verify column exists in table schema
|
||||
RedisModuleString *typeStr = NULL;
|
||||
if (RedisModule_HashGet(schemaKey, REDISMODULE_HASH_NONE, col, &typeStr, NULL) != REDISMODULE_OK || !typeStr)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR column does not exist");
|
||||
|
||||
// Add to index metadata
|
||||
RedisModule_Call(ctx, "SADD", "ss", metaKey, col);
|
||||
|
||||
// Build index for all existing rows
|
||||
RedisModuleString *rowsSet = fmt(ctx, "rows:%s", argv[1]);
|
||||
RedisModuleCallReply *rows = RedisModule_Call(ctx, "SMEMBERS", "s", rowsSet);
|
||||
if (rows && RedisModule_CallReplyType(rows) == REDISMODULE_REPLY_ARRAY) {
|
||||
size_t n = RedisModule_CallReplyLength(rows);
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
RedisModuleCallReply *e = RedisModule_CallReplyArrayElement(rows, i);
|
||||
RedisModuleString *rowId = RedisModule_CreateStringFromCallReply(e);
|
||||
RedisModuleString *rowKey = fmt2(ctx, "%s:%s", argv[1], rowId);
|
||||
|
||||
// Get column value from row
|
||||
RedisModuleCallReply *valReply = RedisModule_Call(ctx, "HGET", "ss", rowKey, col);
|
||||
if (valReply && RedisModule_CallReplyType(valReply) == REDISMODULE_REPLY_STRING) {
|
||||
RedisModuleString *val = RedisModule_CreateStringFromCallReply(valReply);
|
||||
RedisModuleString *idxKey = fmt3(ctx, "idx:%s:%s:%s", argv[1], col, val);
|
||||
RedisModule_Call(ctx, "SADD", "ss", idxKey, rowId);
|
||||
}
|
||||
}
|
||||
}
|
||||
return RedisModule_ReplyWithSimpleString(ctx, "OK");
|
||||
}
|
||||
} else if (oplen == 4 && strncasecmp(op, "DROP", 4) == 0) {
|
||||
if (targetlen == 5 && strncasecmp(target, "INDEX", 5) == 0) {
|
||||
// DROP INDEX col - remove index metadata and delete all index keys
|
||||
if (argc != 5) return RedisModule_ReplyWithError(ctx, "ERR DROP INDEX requires column name");
|
||||
RedisModuleString *col = argv[4];
|
||||
|
||||
// Remove from index metadata
|
||||
RedisModule_Call(ctx, "SREM", "ss", metaKey, col);
|
||||
|
||||
// Delete all index keys for this column (scan pattern idx:table:col:*)
|
||||
RedisModuleString *pattern = fmt2(ctx, "idx:%s:%s:*", argv[1], col);
|
||||
RedisModuleCallReply *keys = RedisModule_Call(ctx, "KEYS", "s", pattern);
|
||||
if (keys && RedisModule_CallReplyType(keys) == REDISMODULE_REPLY_ARRAY) {
|
||||
size_t n = RedisModule_CallReplyLength(keys);
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
RedisModuleCallReply *e = RedisModule_CallReplyArrayElement(keys, i);
|
||||
RedisModuleString *key = RedisModule_CreateStringFromCallReply(e);
|
||||
RedisModule_Call(ctx, "DEL", "s", key);
|
||||
}
|
||||
}
|
||||
return RedisModule_ReplyWithSimpleString(ctx, "OK");
|
||||
}
|
||||
}
|
||||
|
||||
return RedisModule_ReplyWithError(ctx, "ERR syntax: ADD COLUMN col:type[:index] | ADD INDEX col | DROP INDEX col");
|
||||
}
|
||||
|
||||
/* ================== TABLE.INSERT <namespace.table> <col>=<value> ... ================== */
|
||||
static int TableInsertCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc < 3) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
|
||||
if (ensure_table_exists(ctx, argv[1]) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR table schema does not exist");
|
||||
|
||||
RedisModuleString *idKey = fmt(ctx, "table:%s:id", argv[1]);
|
||||
RedisModuleCallReply *idReply = RedisModule_Call(ctx, "INCR", "s", idKey);
|
||||
long long idNum = idReply ? RedisModule_CallReplyInteger(idReply) : 0;
|
||||
RedisModuleString *rowId = RedisModule_CreateStringFromLongLong(ctx, idNum);
|
||||
|
||||
RedisModuleString *rowKey = fmt2(ctx, "%s:%s", argv[1], rowId);
|
||||
RedisModuleKey *row = RedisModule_OpenKey(ctx, rowKey, REDISMODULE_WRITE);
|
||||
RedisModuleString *rowsSet = fmt(ctx, "rows:%s", argv[1]);
|
||||
|
||||
for (int i = 2; i < argc; i++) {
|
||||
RedisModuleString *col=NULL, *val=NULL;
|
||||
char op[3];
|
||||
if (split_condition(ctx, argv[i], &col, op, &val) != REDISMODULE_OK || strcmp(op, "=") != 0)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR each field must be <col>=<value>");
|
||||
if (validate_and_typecheck(ctx, argv[1], col, val) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR invalid column or type");
|
||||
RedisModule_HashSet(row, REDISMODULE_HASH_NONE, col, val, NULL);
|
||||
|
||||
// Only create index if column is indexed
|
||||
if (is_column_indexed(ctx, argv[1], col)) {
|
||||
RedisModuleString *idxKey = fmt3(ctx, "idx:%s:%s:%s", argv[1], col, val);
|
||||
RedisModule_Call(ctx, "SADD", "ss", idxKey, rowId);
|
||||
}
|
||||
}
|
||||
|
||||
RedisModule_Call(ctx, "SADD", "ss", rowsSet, rowId);
|
||||
return RedisModule_ReplyWithString(ctx, rowId);
|
||||
}
|
||||
|
||||
// Collect members of an index set into a dictionary
|
||||
static void dict_add_set_members(RedisModuleCtx *ctx, RedisModuleDict *dict, RedisModuleString *setKey) {
|
||||
RedisModuleCallReply *r = RedisModule_Call(ctx, "SMEMBERS", "s", setKey);
|
||||
if (!r || RedisModule_CallReplyType(r) != REDISMODULE_REPLY_ARRAY) return;
|
||||
size_t n = RedisModule_CallReplyLength(r);
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
RedisModuleCallReply *e = RedisModule_CallReplyArrayElement(r, i);
|
||||
RedisModuleString *id = RedisModule_CreateStringFromCallReply(e);
|
||||
RedisModule_DictSet(dict, id, NULL);
|
||||
}
|
||||
}
|
||||
|
||||
// Filter dictionary based on comparison operator
|
||||
static void dict_filter_condition(RedisModuleCtx *ctx, RedisModuleDict *dict, RedisModuleString *table,
|
||||
RedisModuleString *col, const char *op, RedisModuleString *val) {
|
||||
RedisModuleString *toRemove[1000];
|
||||
size_t removeCount = 0;
|
||||
|
||||
// Get column type
|
||||
RedisModuleKey *schemaKey = RedisModule_OpenKey(ctx, fmt(ctx, "schema:%s", table), REDISMODULE_READ);
|
||||
RedisModuleString *typeStr = NULL;
|
||||
RedisModule_HashGet(schemaKey, REDISMODULE_HASH_NONE, col, &typeStr, NULL);
|
||||
const char *type = "string";
|
||||
if (typeStr) {
|
||||
size_t tlen; const char *t = RedisModule_StringPtrLen(typeStr, &tlen);
|
||||
if (tlen == 7 && strncasecmp(t, "integer", 7) == 0) type = "integer";
|
||||
else if (tlen == 5 && strncasecmp(t, "float", 5) == 0) type = "float";
|
||||
else if (tlen == 4 && strncasecmp(t, "date", 4) == 0) type = "date";
|
||||
}
|
||||
|
||||
size_t vlen; const char *vstr = RedisModule_StringPtrLen(val, &vlen);
|
||||
|
||||
RedisModuleDictIter *it = RedisModule_DictIteratorStartC(dict, "^", NULL, 0);
|
||||
RedisModuleString *key; void *dummy;
|
||||
while ((key = RedisModule_DictNext(ctx, it, &dummy)) != NULL) {
|
||||
RedisModuleString *rowKey = fmt2(ctx, "%s:%s", table, key);
|
||||
RedisModuleCallReply *v = RedisModule_Call(ctx, "HGET", "ss", rowKey, col);
|
||||
int keep = 0;
|
||||
if (v && RedisModule_CallReplyType(v) == REDISMODULE_REPLY_STRING) {
|
||||
RedisModuleString *cur = RedisModule_CreateStringFromCallReply(v);
|
||||
size_t clen; const char *cstr = RedisModule_StringPtrLen(cur, &clen);
|
||||
keep = compare_values(cstr, vstr, op, type);
|
||||
}
|
||||
if (!keep && removeCount < 1000) {
|
||||
toRemove[removeCount++] = key;
|
||||
}
|
||||
}
|
||||
RedisModule_DictIteratorStop(it);
|
||||
|
||||
for (size_t i = 0; i < removeCount; i++) {
|
||||
RedisModule_DictDel(dict, toRemove[i], NULL);
|
||||
}
|
||||
}
|
||||
|
||||
/* ================== TABLE.SELECT <namespace.table> [WHERE col op val (AND|OR col op val ...)] ================== */
|
||||
static int TableSelectCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc < 2) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
if (ensure_table_exists(ctx, argv[1]) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR table schema does not exist");
|
||||
|
||||
int wherePos = -1;
|
||||
for (int i = 2; i < argc; i++) {
|
||||
size_t l; const char *w = RedisModule_StringPtrLen(argv[i], &l);
|
||||
if (l == 5 && strncasecmp(w, "WHERE", 5) == 0) { wherePos = i; break; }
|
||||
}
|
||||
|
||||
RedisModuleDict *ids = RedisModule_CreateDict(ctx);
|
||||
if (wherePos == -1) {
|
||||
dict_add_set_members(ctx, ids, fmt(ctx, "rows:%s", argv[1]));
|
||||
} else {
|
||||
int i = wherePos + 1;
|
||||
int haveSeed = 0;
|
||||
while (i < argc) {
|
||||
RedisModuleString *col=NULL, *val=NULL;
|
||||
char op[3];
|
||||
if (split_condition(ctx, argv[i], &col, op, &val) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR condition must be <col><op><value>");
|
||||
|
||||
// Check if column is indexed (only for = operator, others need full scan)
|
||||
if (strcmp(op, "=") != 0 || !is_column_indexed(ctx, argv[1], col)) {
|
||||
if (strcmp(op, "=") == 0) {
|
||||
return RedisModule_ReplyWithError(ctx, "ERR search cannot be done on non-indexed column");
|
||||
}
|
||||
// For comparison operators, we need to scan all rows
|
||||
if (!haveSeed) {
|
||||
dict_add_set_members(ctx, ids, fmt(ctx, "rows:%s", argv[1]));
|
||||
haveSeed = 1;
|
||||
}
|
||||
dict_filter_condition(ctx, ids, argv[1], col, op, val);
|
||||
i++;
|
||||
} else {
|
||||
// Indexed equality search
|
||||
if (!haveSeed) {
|
||||
dict_add_set_members(ctx, ids, fmt3(ctx, "idx:%s:%s:%s", argv[1], col, val));
|
||||
haveSeed = 1; i++;
|
||||
} else {
|
||||
size_t opl; const char *ops = RedisModule_StringPtrLen(argv[i-1], &opl);
|
||||
if (opl==3 && strncasecmp(ops, "AND",3)==0) {
|
||||
dict_filter_condition(ctx, ids, argv[1], col, op, val);
|
||||
i++;
|
||||
} else if (opl==2 && strncasecmp(ops, "OR",2)==0) {
|
||||
dict_add_set_members(ctx, ids, fmt3(ctx, "idx:%s:%s:%s", argv[1], col, val));
|
||||
i++;
|
||||
} else {
|
||||
return RedisModule_ReplyWithError(ctx, "ERR expected AND/OR between conditions");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (i < argc) {
|
||||
size_t tl; const char *ts = RedisModule_StringPtrLen(argv[i], &tl);
|
||||
if ((tl==3 && strncasecmp(ts, "AND",3)==0) || (tl==2 && strncasecmp(ts, "OR",2)==0)) {
|
||||
i++;
|
||||
if (i >= argc) return RedisModule_ReplyWithError(ctx, "ERR dangling operator");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Build reply
|
||||
RedisModuleDictIter *it = RedisModule_DictIteratorStartC(ids, "^", NULL, 0);
|
||||
RedisModuleString *id; void *dummy;
|
||||
size_t rowCount = 0;
|
||||
while (RedisModule_DictNext(ctx, it, &dummy)) rowCount++;
|
||||
RedisModule_DictIteratorStop(it);
|
||||
|
||||
RedisModule_ReplyWithArray(ctx, rowCount);
|
||||
it = RedisModule_DictIteratorStartC(ids, "^", NULL, 0);
|
||||
while ((id = RedisModule_DictNext(ctx, it, &dummy)) != NULL) {
|
||||
RedisModuleString *rowKey = fmt2(ctx, "%s:%s", argv[1], id);
|
||||
RedisModuleCallReply *all = RedisModule_Call(ctx, "HGETALL", "s", rowKey);
|
||||
if (!all || RedisModule_CallReplyType(all) != REDISMODULE_REPLY_ARRAY) {
|
||||
RedisModule_ReplyWithNull(ctx);
|
||||
continue;
|
||||
}
|
||||
size_t n = RedisModule_CallReplyLength(all);
|
||||
RedisModule_ReplyWithArray(ctx, n);
|
||||
for (size_t j = 0; j < n; j++) {
|
||||
RedisModuleCallReply *e = RedisModule_CallReplyArrayElement(all, j);
|
||||
RedisModule_ReplyWithString(ctx, RedisModule_CreateStringFromCallReply(e));
|
||||
}
|
||||
}
|
||||
RedisModule_DictIteratorStop(it);
|
||||
return REDISMODULE_OK;
|
||||
}
|
||||
|
||||
// Update indices for a single column when value changes
|
||||
static void update_index_for_change(RedisModuleCtx *ctx, RedisModuleString *table, RedisModuleString *col,
|
||||
RedisModuleString *oldv, RedisModuleString *newv, RedisModuleString *rowId) {
|
||||
if (!is_column_indexed(ctx, table, col)) return;
|
||||
if (oldv && RedisModule_StringCompare(oldv, newv) == 0) return;
|
||||
if (oldv) {
|
||||
RedisModuleString *oldIdx = fmt3(ctx, "idx:%s:%s:%s", table, col, oldv);
|
||||
RedisModule_Call(ctx, "SREM", "ss", oldIdx, rowId);
|
||||
}
|
||||
RedisModuleString *newIdx = fmt3(ctx, "idx:%s:%s:%s", table, col, newv);
|
||||
RedisModule_Call(ctx, "SADD", "ss", newIdx, rowId);
|
||||
}
|
||||
|
||||
/* ================== TABLE.UPDATE <namespace.table> WHERE ... SET col=val ... ================== */
|
||||
static int TableUpdateCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc < 5) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
if (ensure_table_exists(ctx, argv[1]) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR table schema does not exist");
|
||||
|
||||
int setPos = -1;
|
||||
for (int i = 2; i < argc; i++) {
|
||||
size_t l; const char *w = RedisModule_StringPtrLen(argv[i], &l);
|
||||
if (l==3 && strncasecmp(w, "SET",3)==0) { setPos = i; break; }
|
||||
}
|
||||
if (setPos == -1) return RedisModule_ReplyWithError(ctx, "ERR missing SET");
|
||||
|
||||
int whereStart = 2;
|
||||
if (setPos > 2) {
|
||||
size_t l; const char *w = RedisModule_StringPtrLen(argv[2], &l);
|
||||
if (l == 5 && strncasecmp(w, "WHERE", 5) == 0) whereStart = 3;
|
||||
}
|
||||
|
||||
RedisModuleDict *ids = RedisModule_CreateDict(ctx);
|
||||
if (whereStart >= setPos) {
|
||||
dict_add_set_members(ctx, ids, fmt(ctx, "rows:%s", argv[1]));
|
||||
} else {
|
||||
int i = whereStart;
|
||||
int haveSeed = 0;
|
||||
while (i < setPos) {
|
||||
RedisModuleString *col=NULL,*val=NULL;
|
||||
char op[3];
|
||||
if (split_condition(ctx, argv[i], &col, op, &val) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR condition must be <col><op><value>");
|
||||
|
||||
if (strcmp(op, "=") == 0 && is_column_indexed(ctx, argv[1], col)) {
|
||||
if (!haveSeed) {
|
||||
dict_add_set_members(ctx, ids, fmt3(ctx, "idx:%s:%s:%s", argv[1], col, val));
|
||||
haveSeed = 1; i++;
|
||||
} else {
|
||||
size_t opl; const char *ops = RedisModule_StringPtrLen(argv[i-1], &opl);
|
||||
if (opl==3 && strncasecmp(ops, "AND",3)==0) {
|
||||
dict_filter_condition(ctx, ids, argv[1], col, op, val);
|
||||
i++;
|
||||
} else if (opl==2 && strncasecmp(ops, "OR",2)==0) {
|
||||
dict_add_set_members(ctx, ids, fmt3(ctx, "idx:%s:%s:%s", argv[1], col, val));
|
||||
i++;
|
||||
} else return RedisModule_ReplyWithError(ctx, "ERR expected AND/OR between conditions");
|
||||
}
|
||||
} else {
|
||||
if (!haveSeed) {
|
||||
dict_add_set_members(ctx, ids, fmt(ctx, "rows:%s", argv[1]));
|
||||
haveSeed = 1;
|
||||
}
|
||||
dict_filter_condition(ctx, ids, argv[1], col, op, val);
|
||||
i++;
|
||||
}
|
||||
|
||||
if (i < setPos) {
|
||||
size_t tl; const char *ts = RedisModule_StringPtrLen(argv[i], &tl);
|
||||
if ((tl==3 && strncasecmp(ts, "AND",3)==0) || (tl==2 && strncasecmp(ts, "OR",2)==0)) {
|
||||
i++; if (i>=setPos) return RedisModule_ReplyWithError(ctx, "ERR dangling operator");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
long long updated = 0;
|
||||
RedisModuleDictIter *it = RedisModule_DictIteratorStartC(ids, "^", NULL, 0);
|
||||
RedisModuleString *id; void *dummy;
|
||||
while ((id = RedisModule_DictNext(ctx, it, &dummy)) != NULL) {
|
||||
RedisModuleString *rowKey = fmt2(ctx, "%s:%s", argv[1], id);
|
||||
for (int j = setPos + 1; j < argc; j++) {
|
||||
RedisModuleString *col=NULL,*val=NULL;
|
||||
char op[3];
|
||||
if (split_condition(ctx, argv[j], &col, op, &val) != REDISMODULE_OK || strcmp(op, "=") != 0)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR SET expects <col>=<value>");
|
||||
if (validate_and_typecheck(ctx, argv[1], col, val) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR invalid column or type");
|
||||
|
||||
RedisModuleCallReply *oldr = RedisModule_Call(ctx, "HGET", "ss", rowKey, col);
|
||||
RedisModuleString *oldv = NULL;
|
||||
if (oldr && RedisModule_CallReplyType(oldr) == REDISMODULE_REPLY_STRING)
|
||||
oldv = RedisModule_CreateStringFromCallReply(oldr);
|
||||
|
||||
RedisModule_Call(ctx, "HSET", "sss", rowKey, col, val);
|
||||
update_index_for_change(ctx, argv[1], col, oldv, val, id);
|
||||
}
|
||||
updated++;
|
||||
}
|
||||
RedisModule_DictIteratorStop(it);
|
||||
return RedisModule_ReplyWithLongLong(ctx, updated);
|
||||
}
|
||||
|
||||
/* ================== TABLE.DELETE <namespace.table> WHERE ... ================== */
|
||||
static int TableDeleteCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc < 2) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
if (ensure_table_exists(ctx, argv[1]) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR table schema does not exist");
|
||||
|
||||
RedisModuleDict *ids = RedisModule_CreateDict(ctx);
|
||||
int hasWhere = 0;
|
||||
for (int i = 2; i < argc; i++) {
|
||||
size_t l; const char *w = RedisModule_StringPtrLen(argv[i], &l);
|
||||
if (l==5 && strncasecmp(w, "WHERE",5)==0) { hasWhere=1; break; }
|
||||
}
|
||||
|
||||
if (!hasWhere) {
|
||||
dict_add_set_members(ctx, ids, fmt(ctx, "rows:%s", argv[1]));
|
||||
} else {
|
||||
int i = 3;
|
||||
int haveSeed = 0;
|
||||
while (i < argc) {
|
||||
RedisModuleString *col=NULL,*val=NULL;
|
||||
char op[3];
|
||||
if (split_condition(ctx, argv[i], &col, op, &val) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR condition must be <col><op><value>");
|
||||
|
||||
if (strcmp(op, "=") == 0 && is_column_indexed(ctx, argv[1], col)) {
|
||||
if (!haveSeed) {
|
||||
dict_add_set_members(ctx, ids, fmt3(ctx, "idx:%s:%s:%s", argv[1], col, val));
|
||||
haveSeed=1; i++;
|
||||
} else {
|
||||
size_t opl; const char *ops = RedisModule_StringPtrLen(argv[i-1], &opl);
|
||||
if (opl==3 && strncasecmp(ops, "AND",3)==0) {
|
||||
dict_filter_condition(ctx, ids, argv[1], col, op, val);
|
||||
i++;
|
||||
} else if (opl==2 && strncasecmp(ops, "OR",2)==0) {
|
||||
dict_add_set_members(ctx, ids, fmt3(ctx, "idx:%s:%s:%s", argv[1], col, val));
|
||||
i++;
|
||||
} else return RedisModule_ReplyWithError(ctx, "ERR expected AND/OR between conditions");
|
||||
}
|
||||
} else {
|
||||
if (!haveSeed) {
|
||||
dict_add_set_members(ctx, ids, fmt(ctx, "rows:%s", argv[1]));
|
||||
haveSeed = 1;
|
||||
}
|
||||
dict_filter_condition(ctx, ids, argv[1], col, op, val);
|
||||
i++;
|
||||
}
|
||||
|
||||
if (i < argc) {
|
||||
size_t tl; const char *ts = RedisModule_StringPtrLen(argv[i], &tl);
|
||||
if ((tl==3 && strncasecmp(ts, "AND",3)==0) || (tl==2 && strncasecmp(ts, "OR",2)==0)) {
|
||||
i++; if (i>=argc) return RedisModule_ReplyWithError(ctx, "ERR dangling operator");
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
long long deleted = 0;
|
||||
RedisModuleString *rowsSet = fmt(ctx, "rows:%s", argv[1]);
|
||||
|
||||
RedisModuleDictIter *it = RedisModule_DictIteratorStartC(ids, "^", NULL, 0);
|
||||
RedisModuleString *id; void *dummy;
|
||||
while ((id = RedisModule_DictNext(ctx, it, &dummy)) != NULL) {
|
||||
RedisModuleString *rowKey = fmt2(ctx, "%s:%s", argv[1], id);
|
||||
|
||||
RedisModuleCallReply *fields = RedisModule_Call(ctx, "HKEYS", "s", fmt(ctx, "schema:%s", argv[1]));
|
||||
if (fields && RedisModule_CallReplyType(fields) == REDISMODULE_REPLY_ARRAY) {
|
||||
size_t n = RedisModule_CallReplyLength(fields);
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
RedisModuleCallReply *fc = RedisModule_CallReplyArrayElement(fields, i);
|
||||
RedisModuleString *col = RedisModule_CreateStringFromCallReply(fc);
|
||||
|
||||
if (is_column_indexed(ctx, argv[1], col)) {
|
||||
RedisModuleCallReply *oldr = RedisModule_Call(ctx, "HGET", "ss", rowKey, col);
|
||||
if (oldr && RedisModule_CallReplyType(oldr) == REDISMODULE_REPLY_STRING) {
|
||||
RedisModuleString *oldv = RedisModule_CreateStringFromCallReply(oldr);
|
||||
RedisModuleString *idxKey = fmt3(ctx, "idx:%s:%s:%s", argv[1], col, oldv);
|
||||
RedisModule_Call(ctx, "SREM", "ss", idxKey, id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RedisModule_Call(ctx, "DEL", "s", rowKey);
|
||||
RedisModule_Call(ctx, "SREM", "ss", rowsSet, id);
|
||||
deleted++;
|
||||
}
|
||||
RedisModule_DictIteratorStop(it);
|
||||
return RedisModule_ReplyWithLongLong(ctx, deleted);
|
||||
}
|
||||
|
||||
/* ================== TABLE.DROP <namespace.table> [FORCE] ================== */
|
||||
static int TableDropCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
if (argc != 2 && argc != 3) return RedisModule_WrongArity(ctx);
|
||||
RedisModule_AutoMemory(ctx);
|
||||
if (ensure_table_exists(ctx, argv[1]) != REDISMODULE_OK)
|
||||
return RedisModule_ReplyWithError(ctx, "ERR table schema does not exist");
|
||||
|
||||
// Check for FORCE parameter
|
||||
if (argc == 2) {
|
||||
return RedisModule_ReplyWithError(ctx, "ERR This operation is irreversible, use FORCE parameter to remove the table");
|
||||
}
|
||||
|
||||
// Verify FORCE parameter
|
||||
const char *force_param = RedisModule_StringPtrLen(argv[2], NULL);
|
||||
if (strcasecmp(force_param, "FORCE") != 0) {
|
||||
return RedisModule_ReplyWithError(ctx, "ERR Invalid parameter. Use FORCE to confirm table removal");
|
||||
}
|
||||
|
||||
RedisModuleString *rowsSet = fmt(ctx, "rows:%s", argv[1]);
|
||||
RedisModuleCallReply *rows = RedisModule_Call(ctx, "SMEMBERS", "s", rowsSet);
|
||||
if (rows && RedisModule_CallReplyType(rows) == REDISMODULE_REPLY_ARRAY) {
|
||||
size_t n = RedisModule_CallReplyLength(rows);
|
||||
for (size_t i = 0; i < n; i++) {
|
||||
RedisModuleCallReply *e = RedisModule_CallReplyArrayElement(rows, i);
|
||||
RedisModuleString *id = RedisModule_CreateStringFromCallReply(e);
|
||||
RedisModuleString *rowKey = fmt2(ctx, "%s:%s", argv[1], id);
|
||||
|
||||
RedisModuleCallReply *fields = RedisModule_Call(ctx, "HKEYS", "s", fmt(ctx, "schema:%s", argv[1]));
|
||||
if (fields && RedisModule_CallReplyType(fields) == REDISMODULE_REPLY_ARRAY) {
|
||||
size_t fn = RedisModule_CallReplyLength(fields);
|
||||
for (size_t j = 0; j < fn; j++) {
|
||||
RedisModuleCallReply *fc = RedisModule_CallReplyArrayElement(fields, j);
|
||||
RedisModuleString *col = RedisModule_CreateStringFromCallReply(fc);
|
||||
|
||||
if (is_column_indexed(ctx, argv[1], col)) {
|
||||
RedisModuleCallReply *oldr = RedisModule_Call(ctx, "HGET", "ss", rowKey, col);
|
||||
if (oldr && RedisModule_CallReplyType(oldr) == REDISMODULE_REPLY_STRING) {
|
||||
RedisModuleString *oldv = RedisModule_CreateStringFromCallReply(oldr);
|
||||
RedisModuleString *idxKey = fmt3(ctx, "idx:%s:%s:%s", argv[1], col, oldv);
|
||||
RedisModule_Call(ctx, "SREM", "ss", idxKey, id);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
RedisModule_Call(ctx, "DEL", "s", rowKey);
|
||||
RedisModule_Call(ctx, "SREM", "ss", rowsSet, id);
|
||||
}
|
||||
}
|
||||
|
||||
RedisModule_Call(ctx, "DEL", "s", fmt(ctx, "schema:%s", argv[1]));
|
||||
RedisModule_Call(ctx, "DEL", "s", fmt(ctx, "table:%s:id", argv[1]));
|
||||
RedisModule_Call(ctx, "DEL", "s", fmt(ctx, "idx:meta:%s", argv[1]));
|
||||
RedisModule_Call(ctx, "DEL", "s", rowsSet);
|
||||
return RedisModule_ReplyWithSimpleString(ctx, "OK");
|
||||
}
|
||||
|
||||
/* ================== TABLE.HELP ================== */
|
||||
static int TableHelpCommand(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
(void)argv; (void)argc;
|
||||
const char *help[] = {
|
||||
"TABLE.NAMESPACE.CREATE <namespace>",
|
||||
"TABLE.NAMESPACE.VIEW [<namespace>] - Display all namespace:table pairs, optionally filtered by namespace",
|
||||
"TABLE.SCHEMA.VIEW <namespace.table> - Display columns, types, and index status",
|
||||
"TABLE.SCHEMA.CREATE <namespace.table> <col:type[:index]> [<col:type[:index]> ...]",
|
||||
" Types: string, integer, float, date (YYYY-MM-DD)",
|
||||
"TABLE.SCHEMA.ALTER <namespace.table> ADD COLUMN <col:type[:index]> | ADD INDEX <col> | DROP INDEX <col>",
|
||||
" ADD INDEX builds index for existing data",
|
||||
"TABLE.INSERT <namespace.table> <col>=<value> [<col>=<value> ...]",
|
||||
"TABLE.SELECT <namespace.table> [WHERE <col><op><value> (AND|OR <col><op><value> ...)]",
|
||||
" Operators: = > < >= <=",
|
||||
" Note: Only indexed columns can use = in WHERE",
|
||||
"TABLE.UPDATE <namespace.table> WHERE <cond> (AND|OR <cond> ...) SET <col>=<value> [<col>=<value> ...]",
|
||||
"TABLE.DELETE <namespace.table> [WHERE <cond> (AND|OR <cond> ...)]",
|
||||
"TABLE.DROP <namespace.table> FORCE",
|
||||
" FORCE parameter is required to confirm irreversible deletion",
|
||||
"TABLE.HELP"
|
||||
};
|
||||
size_t n = sizeof(help)/sizeof(help[0]);
|
||||
RedisModule_ReplyWithArray(ctx, n);
|
||||
for (size_t i = 0; i < n; i++) RedisModule_ReplyWithSimpleString(ctx, help[i]);
|
||||
return REDISMODULE_OK;
|
||||
}
|
||||
|
||||
/* ================== Module Init ================== */
|
||||
int RedisModule_OnLoad(RedisModuleCtx *ctx, RedisModuleString **argv, int argc) {
|
||||
REDISMODULE_NOT_USED(argv);
|
||||
REDISMODULE_NOT_USED(argc);
|
||||
if (RedisModule_Init(ctx, "table", 2, REDISMODULE_APIVER_1) == REDISMODULE_ERR)
|
||||
return REDISMODULE_ERR;
|
||||
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.NAMESPACE.CREATE", TableNamespaceCreateCommand, "write", 1, 1, 1) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.NAMESPACE.VIEW", TableNamespaceViewCommand, "readonly", 0, 0, 0) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.SCHEMA.VIEW", TableSchemaViewCommand, "readonly", 1, 1, 1) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.SCHEMA.CREATE", TableSchemaCreateCommand, "write", 1, 1, 1) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.SCHEMA.ALTER", TableSchemaAlterCommand, "write", 1, 1, 1) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.INSERT", TableInsertCommand, "write", 1, 1, 1) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.SELECT", TableSelectCommand, "readonly", 1, 1, 1) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.UPDATE", TableUpdateCommand, "write", 1, 1, 1) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.DELETE", TableDeleteCommand, "write", 1, 1, 1) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.DROP", TableDropCommand, "write", 1, 1, 1) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
if (RedisModule_CreateCommand(ctx, "TABLE.HELP", TableHelpCommand, "readonly", 0, 0, 0) == REDISMODULE_ERR) return REDISMODULE_ERR;
|
||||
|
||||
return REDISMODULE_OK;
|
||||
}
|
||||
|
|
@ -0,0 +1,635 @@
|
|||
# Redis Table Module - Testing Guide
|
||||
|
||||
Complete testing documentation for the Redis Table Module, including unit tests, manual testing procedures, and test coverage information.
|
||||
|
||||
## Table of Contents
|
||||
|
||||
1. [Quick Start](#quick-start)
|
||||
2. [Test Suite Overview](#test-suite-overview)
|
||||
3. [Running Tests](#running-tests)
|
||||
4. [Test Coverage](#test-coverage)
|
||||
5. [Manual Testing](#manual-testing)
|
||||
6. [Test Data Setup](#test-data-setup)
|
||||
7. [Troubleshooting](#troubleshooting)
|
||||
|
||||
---
|
||||
|
||||
## Quick Start
|
||||
|
||||
### Prerequisites
|
||||
|
||||
1. **Build the module** (if not already built):
|
||||
```bash
|
||||
cd /home/ubuntu/Projects/REDIS/redis/modules/redistable
|
||||
make
|
||||
```
|
||||
|
||||
2. **Test scripts are already executable** and paths are configured correctly.
|
||||
|
||||
### Run All Tests
|
||||
|
||||
**Option 1: Using the Makefile (recommended)**
|
||||
```bash
|
||||
cd /home/ubuntu/Projects/REDIS/redis/modules/redistable
|
||||
make test
|
||||
```
|
||||
This automatically builds the module, starts Redis, runs all tests, and cleans up.
|
||||
|
||||
**Option 2: Using the test runner directly**
|
||||
```bash
|
||||
cd /home/ubuntu/Projects/REDIS/redis/modules/redistable/tests
|
||||
./run_tests.sh
|
||||
```
|
||||
This script automatically starts Redis with the module, runs tests, and cleans up.
|
||||
|
||||
**Option 3: Manual execution**
|
||||
```bash
|
||||
# Start Redis with the module
|
||||
cd /home/ubuntu/Projects/REDIS/redis
|
||||
./src/redis-server --loadmodule modules/redistable/redis_table.so --daemonize yes
|
||||
|
||||
# Run tests
|
||||
cd modules/redistable/tests
|
||||
./test_redis_table.sh
|
||||
```
|
||||
|
||||
### Expected Output
|
||||
|
||||
```
|
||||
========================================
|
||||
Redis Table Module - Test Runner
|
||||
========================================
|
||||
|
||||
Starting Redis server with table module...
|
||||
Redis server started successfully
|
||||
|
||||
Cleaning database...
|
||||
Running test suite...
|
||||
|
||||
========================================
|
||||
Redis Table Module - Unit Test Suite
|
||||
========================================
|
||||
|
||||
=== TEST SUITE 1: Namespace Management ===
|
||||
Test 1: Create namespace
|
||||
✓ PASS: Namespace creation should return OK
|
||||
...
|
||||
|
||||
========================================
|
||||
Test Summary
|
||||
========================================
|
||||
Passed: 86
|
||||
Failed: 0
|
||||
Total: 86
|
||||
========================================
|
||||
All tests completed successfully!
|
||||
|
||||
Stopping Redis server...
|
||||
Redis server stopped
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Test Suite Overview
|
||||
|
||||
The test suite contains **14 comprehensive test suites** with **86 individual tests** covering all module functionality:
|
||||
|
||||
### Test Suite 1: Namespace Management (4 tests)
|
||||
- ✅ Create namespace
|
||||
- ✅ Duplicate namespace detection
|
||||
- ✅ View namespaces (empty before tables created)
|
||||
- ✅ Table creation without namespace validation
|
||||
|
||||
### Test Suite 2: Table Creation (8 tests)
|
||||
- ✅ Basic table creation with string/integer types
|
||||
- ✅ All data types (string, integer, float, date)
|
||||
- ✅ Explicit index control (indexed=true/false)
|
||||
- ✅ Duplicate table detection
|
||||
- ✅ Invalid format handling
|
||||
- ✅ View all namespace tables
|
||||
- ✅ View specific namespace tables (filtered)
|
||||
- ✅ View non-existent namespace (returns empty)
|
||||
|
||||
### Test Suite 3: Table Schema Viewing (2 tests)
|
||||
- ✅ View table schema with columns, types, and index status
|
||||
- ✅ Non-existent table error handling
|
||||
|
||||
### Test Suite 4: Data Insertion (9 tests)
|
||||
- ✅ Basic row insertion with auto-increment ID
|
||||
- ✅ Integer type validation
|
||||
- ✅ Float type validation and insertion
|
||||
- ✅ Date type validation (YYYY-MM-DD format)
|
||||
- ✅ Invalid data type rejection
|
||||
- ✅ Invalid date format rejection
|
||||
- ✅ Non-existent column detection
|
||||
|
||||
### Test Suite 5: Data Selection - Basic (3 tests)
|
||||
- ✅ Select all rows
|
||||
- ✅ Equality search on indexed columns
|
||||
- ✅ Equality search validation on non-indexed columns
|
||||
|
||||
### Test Suite 6: Comparison Operators (8 tests)
|
||||
- ✅ Greater than (>) on integers
|
||||
- ✅ Less than (<) on integers
|
||||
- ✅ Greater than or equal (>=) on integers
|
||||
- ✅ Less than or equal (<=) on integers
|
||||
- ✅ Comparison operators on float values
|
||||
- ✅ Comparison operators on date values
|
||||
|
||||
### Test Suite 7: Logical Operators (2 tests)
|
||||
- ✅ AND operator with multiple conditions
|
||||
- ✅ OR operator with multiple conditions
|
||||
|
||||
### Test Suite 8: Table Alteration (7 tests)
|
||||
- ✅ Add indexed column
|
||||
- ✅ Add non-indexed column
|
||||
- ✅ Add index to existing column (with auto-build)
|
||||
- ✅ Verify index functionality after addition
|
||||
- ✅ Add index to non-existent column (error)
|
||||
- ✅ Drop index
|
||||
- ✅ Verify index removal
|
||||
|
||||
### Test Suite 9: Data Update (5 tests)
|
||||
- ✅ Update with WHERE clause
|
||||
- ✅ Verify updated values
|
||||
- ✅ Update multiple rows
|
||||
- ✅ Invalid type validation on update
|
||||
- ✅ Update all rows (no WHERE clause)
|
||||
|
||||
### Test Suite 10: Data Deletion (3 tests)
|
||||
- ✅ Delete with WHERE clause
|
||||
- ✅ Verify deletion
|
||||
- ✅ Delete with comparison operators
|
||||
|
||||
### Test Suite 11: Table Drop (6 tests)
|
||||
- ✅ Drop table without FORCE parameter (should fail)
|
||||
- ✅ Verify table still exists after failed drop
|
||||
- ✅ Drop table with invalid parameter
|
||||
- ✅ Drop table with FORCE parameter
|
||||
- ✅ Verify table dropped
|
||||
- ✅ Drop non-existent table with FORCE
|
||||
|
||||
### Test Suite 12: Edge Cases (6 tests)
|
||||
- ✅ Negative integers
|
||||
- ✅ Negative floats
|
||||
- ✅ String comparison operators
|
||||
- ✅ Empty WHERE clause (returns empty result)
|
||||
- ✅ Dangling operator detection
|
||||
- ✅ Invalid condition format handling
|
||||
|
||||
### Test Suite 13: Help Command (3 tests)
|
||||
- ✅ Help should contain TABLE.SCHEMA.CREATE
|
||||
- ✅ Help should contain TABLE.SELECT
|
||||
- ✅ Help should contain TABLE.INSERT
|
||||
|
||||
### Test Suite 14: Index Maintenance (3 tests)
|
||||
- ✅ Index creation on insert
|
||||
- ✅ Index update on row update
|
||||
- ✅ Index removal on row delete
|
||||
|
||||
### Test Suite 15: Complex Scenarios (6 tests)
|
||||
- ✅ Insert multiple employees
|
||||
- ✅ Complex query: Department + Age range
|
||||
- ✅ Complex query: Salary range
|
||||
- ✅ Complex query: Date range
|
||||
- ✅ Add index and query
|
||||
- ✅ Update salary and verify
|
||||
|
||||
**Total: 86 individual test cases**
|
||||
|
||||
---
|
||||
|
||||
## Running Tests
|
||||
|
||||
### Run Complete Test Suite
|
||||
|
||||
**Using Makefile (recommended)**:
|
||||
```bash
|
||||
cd /home/ubuntu/Projects/REDIS/redis/modules/redistable
|
||||
make test
|
||||
```
|
||||
|
||||
**Direct execution**:
|
||||
```bash
|
||||
cd /home/ubuntu/Projects/REDIS/redis/modules/redistable/tests
|
||||
./test_redis_table.sh
|
||||
```
|
||||
|
||||
### Run Specific Test Suite
|
||||
|
||||
You can modify the script to run specific suites by commenting out sections:
|
||||
|
||||
```bash
|
||||
# Edit test_redis_table.sh and comment out unwanted test suites
|
||||
# Example: Comment out lines for TEST SUITE 2 to skip table creation tests
|
||||
```
|
||||
|
||||
### Run with Verbose Output
|
||||
|
||||
The test script already provides detailed output. For even more detail, you can add debug output:
|
||||
|
||||
```bash
|
||||
# Add this to the beginning of test_redis_table.sh
|
||||
set -x # Enable bash debug mode
|
||||
```
|
||||
|
||||
### Run Tests in CI/CD
|
||||
|
||||
```bash
|
||||
#!/bin/bash
|
||||
# CI/CD integration example
|
||||
|
||||
cd /home/ubuntu/Projects/REDIS/redis/modules/redistable
|
||||
|
||||
# Build and test using Makefile
|
||||
make clean
|
||||
make
|
||||
make test
|
||||
|
||||
# Capture exit code
|
||||
TEST_RESULT=$?
|
||||
|
||||
# Exit with test result
|
||||
exit $TEST_RESULT
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Test Coverage
|
||||
|
||||
### Commands Tested
|
||||
|
||||
| Command | Coverage | Test Suites |
|
||||
|---------|----------|-------------|
|
||||
| `TABLE.NAMESPACE.CREATE` | ✅ 100% | 1 |
|
||||
| `TABLE.NAMESPACE.VIEW` | ✅ 100% | 2 |
|
||||
| `TABLE.SCHEMA.VIEW` | ✅ 100% | 3 |
|
||||
| `TABLE.SCHEMA.CREATE` | ✅ 100% | 2 |
|
||||
| `TABLE.SCHEMA.ALTER` | ✅ 100% | 8 |
|
||||
| `TABLE.INSERT` | ✅ 100% | 4, 14, 15 |
|
||||
| `TABLE.SELECT` | ✅ 100% | 5, 6, 7, 15 |
|
||||
| `TABLE.UPDATE` | ✅ 100% | 9, 14, 15 |
|
||||
| `TABLE.DELETE` | ✅ 100% | 10, 14 |
|
||||
| `TABLE.DROP` | ✅ 100% | 11 |
|
||||
| `TABLE.HELP` | ✅ 100% | 13 |
|
||||
|
||||
### Data Types Tested
|
||||
|
||||
| Type | Validation | Comparison | Edge Cases |
|
||||
|------|------------|------------|------------|
|
||||
| `string` | ✅ | ✅ | ✅ |
|
||||
| `integer` | ✅ | ✅ | ✅ (negative) |
|
||||
| `float` | ✅ | ✅ | ✅ (negative, decimal) |
|
||||
| `date` | ✅ | ✅ | ✅ (format validation) |
|
||||
|
||||
### Operators Tested
|
||||
|
||||
| Operator | Integer | Float | Date | String |
|
||||
|----------|---------|-------|------|--------|
|
||||
| `=` | ✅ | ✅ | ✅ | ✅ |
|
||||
| `>` | ✅ | ✅ | ✅ | ✅ |
|
||||
| `<` | ✅ | ✅ | ✅ | ✅ |
|
||||
| `>=` | ✅ | ✅ | ✅ | ✅ |
|
||||
| `<=` | ✅ | ✅ | ✅ | ✅ |
|
||||
| `AND` | ✅ | ✅ | ✅ | ✅ |
|
||||
| `OR` | ✅ | ✅ | ✅ | ✅ |
|
||||
|
||||
### Error Handling Tested
|
||||
|
||||
- ✅ Schema does not exist
|
||||
- ✅ Table does not exist
|
||||
- ✅ Duplicate schema/table
|
||||
- ✅ Invalid column format
|
||||
- ✅ Invalid data types
|
||||
- ✅ Non-indexed column equality search
|
||||
- ✅ Non-existent column
|
||||
- ✅ Invalid operators
|
||||
- ✅ Dangling operators
|
||||
- ✅ Empty WHERE clause
|
||||
|
||||
---
|
||||
|
||||
## Manual Testing
|
||||
|
||||
### Basic Workflow Test
|
||||
|
||||
```bash
|
||||
# 1. Start Redis with module
|
||||
cd /home/ubuntu/Projects/REDIS/redis
|
||||
./src/redis-server --loadmodule modules/redistable/redis_table.so
|
||||
|
||||
# 2. In another terminal, connect to Redis
|
||||
./src/redis-cli
|
||||
|
||||
# 3. Create namespace and table
|
||||
TABLE.NAMESPACE.CREATE testdb
|
||||
TABLE.SCHEMA.CREATE testdb.users NAME:string:true AGE:integer:false EMAIL:string:true
|
||||
|
||||
# 4. View all tables
|
||||
TABLE.NAMESPACE.VIEW
|
||||
|
||||
# 5. View tables in specific namespace
|
||||
TABLE.NAMESPACE.VIEW testdb
|
||||
|
||||
# 6. View table schema
|
||||
TABLE.SCHEMA.VIEW testdb.users
|
||||
|
||||
# 5. Insert data
|
||||
TABLE.INSERT testdb.users NAME=John AGE=30 EMAIL=john@example.com
|
||||
TABLE.INSERT testdb.users NAME=Jane AGE=25 EMAIL=jane@example.com
|
||||
|
||||
# 6. Query data
|
||||
TABLE.SELECT testdb.users
|
||||
TABLE.SELECT testdb.users WHERE NAME=John
|
||||
TABLE.SELECT testdb.users WHERE AGE>25
|
||||
|
||||
# 7. Update data
|
||||
TABLE.UPDATE testdb.users WHERE NAME=John SET AGE=31
|
||||
|
||||
# 8. Delete data
|
||||
TABLE.DELETE testdb.users WHERE AGE<26
|
||||
|
||||
# 9. Clean up
|
||||
TABLE.DROP testdb.users FORCE
|
||||
```
|
||||
|
||||
### Test All Data Types
|
||||
|
||||
```bash
|
||||
TABLE.NAMESPACE.CREATE typetest
|
||||
TABLE.SCHEMA.CREATE typetest.data STR:string INT:integer FLT:float DT:date
|
||||
|
||||
# Insert with all types
|
||||
TABLE.INSERT typetest.data STR=hello INT=42 FLT=3.14 DT=2024-01-15
|
||||
|
||||
# Test comparisons
|
||||
TABLE.SELECT typetest.data WHERE INT>40
|
||||
TABLE.SELECT typetest.data WHERE FLT>=3.0
|
||||
TABLE.SELECT typetest.data WHERE DT>2024-01-01
|
||||
TABLE.SELECT typetest.data WHERE STR=hello
|
||||
```
|
||||
|
||||
### Test Namespace Viewing
|
||||
|
||||
```bash
|
||||
# Create multiple namespaces and tables
|
||||
TABLE.NAMESPACE.CREATE db1
|
||||
TABLE.NAMESPACE.CREATE db2
|
||||
TABLE.SCHEMA.CREATE db1.users NAME:string AGE:integer
|
||||
TABLE.SCHEMA.CREATE db1.products ID:string PRICE:float
|
||||
TABLE.SCHEMA.CREATE db2.orders ORDERID:string TOTAL:float
|
||||
|
||||
# View all tables across all namespaces
|
||||
TABLE.NAMESPACE.VIEW
|
||||
# Expected output:
|
||||
# 1) "db1:products"
|
||||
# 2) "db1:users"
|
||||
# 3) "db2:orders"
|
||||
|
||||
# View tables in specific namespace
|
||||
TABLE.NAMESPACE.VIEW db1
|
||||
# Expected output:
|
||||
# 1) "db1:products"
|
||||
# 2) "db1:users"
|
||||
|
||||
# View non-existent namespace
|
||||
TABLE.NAMESPACE.VIEW nonexistent
|
||||
# Expected output: (empty array)
|
||||
```
|
||||
|
||||
### Test Index Control
|
||||
|
||||
```bash
|
||||
TABLE.NAMESPACE.CREATE idxtest
|
||||
TABLE.SCHEMA.CREATE idxtest.data COL1:string:true COL2:string:false
|
||||
|
||||
# This works (COL1 is indexed)
|
||||
TABLE.INSERT idxtest.data COL1=value1 COL2=value2
|
||||
TABLE.SELECT idxtest.data WHERE COL1=value1
|
||||
|
||||
# This fails (COL2 is not indexed)
|
||||
TABLE.SELECT idxtest.data WHERE COL2=value2
|
||||
|
||||
# Add index dynamically
|
||||
TABLE.SCHEMA.ALTER idxtest.data ADD INDEX COL2
|
||||
|
||||
# Now this works
|
||||
TABLE.SELECT idxtest.data WHERE COL2=value2
|
||||
```
|
||||
|
||||
### Test Complex Queries
|
||||
|
||||
```bash
|
||||
TABLE.NAMESPACE.CREATE company
|
||||
TABLE.SCHEMA.CREATE company.employees EMPID:string:true NAME:string:true DEPT:string:true SALARY:float:false AGE:integer:false HIREDATE:date:true
|
||||
|
||||
# Insert test data
|
||||
TABLE.INSERT company.employees EMPID=E001 NAME=John DEPT=Engineering SALARY=50000.50 AGE=30 HIREDATE=2020-01-15
|
||||
TABLE.INSERT company.employees EMPID=E002 NAME=Jane DEPT=Marketing SALARY=55000.75 AGE=28 HIREDATE=2021-03-20
|
||||
TABLE.INSERT company.employees EMPID=E003 NAME=Bob DEPT=Engineering SALARY=60000.00 AGE=35 HIREDATE=2019-06-10
|
||||
TABLE.INSERT company.employees EMPID=E004 NAME=Alice DEPT=Sales SALARY=58000.25 AGE=32 HIREDATE=2020-11-05
|
||||
|
||||
# Complex queries
|
||||
TABLE.SELECT company.employees WHERE DEPT=Engineering AND AGE>28
|
||||
TABLE.SELECT company.employees WHERE SALARY>=55000 AND SALARY<=60000
|
||||
TABLE.SELECT company.employees WHERE HIREDATE>=2020-01-01 AND HIREDATE<=2020-12-31
|
||||
TABLE.SELECT company.employees WHERE DEPT=Engineering OR DEPT=Sales
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Test Data Setup
|
||||
|
||||
### Small Dataset (for quick tests)
|
||||
|
||||
```bash
|
||||
TABLE.NAMESPACE.CREATE small
|
||||
TABLE.SCHEMA.CREATE small.users NAME:string AGE:integer
|
||||
TABLE.INSERT small.users NAME=Alice AGE=25
|
||||
TABLE.INSERT small.users NAME=Bob AGE=30
|
||||
TABLE.INSERT small.users NAME=Charlie AGE=35
|
||||
```
|
||||
|
||||
### Medium Dataset (for performance tests)
|
||||
|
||||
```bash
|
||||
TABLE.NAMESPACE.CREATE medium
|
||||
TABLE.SCHEMA.CREATE medium.products ID:string:true NAME:string:true PRICE:float:false STOCK:integer:false
|
||||
|
||||
# Insert 100 products
|
||||
for i in {1..100}; do
|
||||
redis-cli TABLE.INSERT medium.products ID=P$(printf "%03d" $i) NAME=Product$i PRICE=$((RANDOM % 1000)).99 STOCK=$((RANDOM % 100))
|
||||
done
|
||||
```
|
||||
|
||||
### Large Dataset (for stress tests)
|
||||
|
||||
```bash
|
||||
TABLE.NAMESPACE.CREATE large
|
||||
TABLE.SCHEMA.CREATE large.events EVENTID:string:true TYPE:string:true TIMESTAMP:date:true VALUE:integer:false
|
||||
|
||||
# Insert 1000 events
|
||||
for i in {1..1000}; do
|
||||
redis-cli TABLE.INSERT large.events EVENTID=EVT$(printf "%04d" $i) TYPE=Type$((RANDOM % 10)) TIMESTAMP=2024-01-$(printf "%02d" $((RANDOM % 28 + 1))) VALUE=$((RANDOM % 1000))
|
||||
done
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Troubleshooting
|
||||
|
||||
### Test Failures
|
||||
|
||||
#### Problem: "Connection refused"
|
||||
**Solution:** Redis server is not running. Start it:
|
||||
```bash
|
||||
cd /home/ubuntu/Projects/REDIS/redis
|
||||
./src/redis-server --loadmodule modules/redistable/redis_table.so
|
||||
```
|
||||
|
||||
#### Problem: "Unknown command 'TABLE.SCHEMA.CREATE'"
|
||||
**Solution:** Module not loaded. Check Redis startup:
|
||||
```bash
|
||||
cd /home/ubuntu/Projects/REDIS/redis
|
||||
./src/redis-server --loadmodule modules/redistable/redis_table.so
|
||||
```
|
||||
|
||||
#### Problem: Tests fail with "ERR namespace already exists"
|
||||
**Solution:** Previous test data not cleaned. Run:
|
||||
```bash
|
||||
redis-cli FLUSHALL
|
||||
./test_redis_table.sh
|
||||
```
|
||||
|
||||
#### Problem: "Permission denied" when running test script
|
||||
**Solution:** Make script executable:
|
||||
```bash
|
||||
chmod +x test_redis_table.sh
|
||||
```
|
||||
|
||||
### Debugging Individual Tests
|
||||
|
||||
To debug a specific test, run commands manually:
|
||||
|
||||
```bash
|
||||
# Enable verbose output
|
||||
redis-cli --verbose
|
||||
|
||||
# Run specific command
|
||||
redis-cli TABLE.SCHEMA.CREATE testdb.users NAME:string AGE:integer
|
||||
|
||||
# Check underlying keys
|
||||
redis-cli KEYS "*testdb*"
|
||||
redis-cli HGETALL schema:testdb.users
|
||||
redis-cli SMEMBERS idx:meta:testdb.users
|
||||
```
|
||||
|
||||
### Performance Testing
|
||||
|
||||
```bash
|
||||
# Measure insert performance
|
||||
time for i in {1..1000}; do
|
||||
redis-cli TABLE.INSERT testdb.perf ID=$i VALUE=$((RANDOM))
|
||||
done
|
||||
|
||||
# Measure query performance
|
||||
time redis-cli TABLE.SELECT testdb.perf WHERE ID=500
|
||||
|
||||
# Check memory usage
|
||||
redis-cli INFO memory
|
||||
```
|
||||
|
||||
### Verify Index Integrity
|
||||
|
||||
```bash
|
||||
# Check if indexes are created correctly
|
||||
redis-cli KEYS "idx:testdb.users:*"
|
||||
|
||||
# Verify index contents
|
||||
redis-cli SMEMBERS "idx:testdb.users:NAME:John"
|
||||
|
||||
# Compare with actual row
|
||||
redis-cli HGETALL "testdb.users:1"
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Continuous Integration
|
||||
|
||||
### GitHub Actions Example
|
||||
|
||||
```yaml
|
||||
name: Redis Table Module Tests
|
||||
|
||||
on: [push, pull_request]
|
||||
|
||||
jobs:
|
||||
test:
|
||||
runs-on: ubuntu-latest
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v2
|
||||
|
||||
- name: Install Redis
|
||||
run: |
|
||||
sudo apt-get update
|
||||
sudo apt-get install -y redis-server
|
||||
|
||||
- name: Build and Test Module
|
||||
run: |
|
||||
cd modules/redistable
|
||||
make clean
|
||||
make
|
||||
make test
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## Test Maintenance
|
||||
|
||||
### Adding New Tests
|
||||
|
||||
1. **Identify the test suite** where your test belongs
|
||||
2. **Follow the naming convention**: `test_start "Description"`
|
||||
3. **Use assertion helpers**: `assert_equals`, `assert_contains`, `assert_error`
|
||||
4. **Clean up test data** if needed
|
||||
|
||||
Example:
|
||||
```bash
|
||||
test_start "My new test"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.CREATE testdb.newtable COL:string)
|
||||
assert_equals "OK" "$result" "New test description"
|
||||
```
|
||||
|
||||
### Updating Tests
|
||||
|
||||
When modifying the module:
|
||||
1. Update affected tests in `test_redis_table.sh`
|
||||
2. Update this documentation
|
||||
3. Run full test suite to ensure no regressions
|
||||
4. Update test count in summary section
|
||||
|
||||
---
|
||||
|
||||
## Summary
|
||||
|
||||
The Redis Table Module test suite provides:
|
||||
|
||||
- ✅ **Comprehensive coverage** of all commands and features
|
||||
- ✅ **86 individual test cases** across 14 test suites
|
||||
- ✅ **Automated testing** with clear pass/fail indicators
|
||||
- ✅ **Integrated Makefile** with `make test` target
|
||||
- ✅ **Manual testing procedures** for development and debugging
|
||||
- ✅ **Performance testing** guidelines
|
||||
- ✅ **CI/CD integration** examples
|
||||
- ✅ **Automatic Redis server management** (start/stop)
|
||||
- ✅ **100% test pass rate** with comprehensive error handling
|
||||
|
||||
For questions or issues, refer to the main [README.md](../README.md) or examine the test script source code.
|
||||
|
||||
---
|
||||
|
||||
**Last Updated:** 2025-10-03
|
||||
**Test Suite Version:** 2.0
|
||||
**Module Version:** 2.0
|
||||
**Build System:** Fully integrated with Makefile
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#!/bin/bash
|
||||
|
||||
# Redis Table Module Testing
|
||||
# Author: Raphael Drai
|
||||
# Email: raphael.drai@gmail.com
|
||||
# Date: October 3, 2025
|
||||
|
||||
# Redis Table Module - Test Runner Script
|
||||
# Convenience script to start Redis, run tests, and clean up
|
||||
|
||||
REDIS_DIR="../../.."
|
||||
MODULE_PATH="$(pwd)/../redis_table.so"
|
||||
REDIS_PID_FILE="/tmp/redis_table_test.pid"
|
||||
|
||||
# Colors
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
BLUE='\033[0;34m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
echo -e "${BLUE}========================================"
|
||||
echo "Redis Table Module - Test Runner"
|
||||
echo -e "========================================${NC}\n"
|
||||
|
||||
# Check if module exists
|
||||
if [ ! -f "$MODULE_PATH" ]; then
|
||||
echo -e "${RED}Error: Module not found at $MODULE_PATH${NC}"
|
||||
echo "Please run 'make' first to build the module."
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# Check if Redis is already running
|
||||
if pgrep -x redis-server > /dev/null; then
|
||||
echo -e "${YELLOW}Warning: Redis server is already running${NC}"
|
||||
echo "Stopping existing Redis instance..."
|
||||
$REDIS_DIR/src/redis-cli SHUTDOWN NOSAVE 2>/dev/null
|
||||
sleep 1
|
||||
pkill -9 redis-server 2>/dev/null
|
||||
sleep 1
|
||||
fi
|
||||
|
||||
echo -e "${GREEN}Starting Redis server with table module...${NC}"
|
||||
cd $REDIS_DIR
|
||||
./src/redis-server --loadmodule $MODULE_PATH --daemonize yes --pidfile $REDIS_PID_FILE
|
||||
sleep 1
|
||||
cd - > /dev/null
|
||||
|
||||
# Verify Redis started
|
||||
if ! pgrep -x redis-server > /dev/null; then
|
||||
echo -e "${RED}Error: Failed to start Redis server${NC}"
|
||||
exit 1
|
||||
fi
|
||||
echo -e "${GREEN}Redis server started successfully${NC}\n"
|
||||
|
||||
# Clean database before tests
|
||||
echo -e "${YELLOW}Cleaning database...${NC}"
|
||||
$REDIS_DIR/src/redis-cli FLUSHALL > /dev/null
|
||||
|
||||
# Run tests
|
||||
echo -e "${GREEN}Running test suite...${NC}\n"
|
||||
./test_redis_table.sh
|
||||
TEST_EXIT_CODE=$?
|
||||
|
||||
# Cleanup - Always stop Redis after tests
|
||||
echo -e "\n${YELLOW}Stopping Redis server...${NC}"
|
||||
$REDIS_DIR/src/redis-cli SHUTDOWN NOSAVE 2>/dev/null
|
||||
sleep 1
|
||||
|
||||
# Force kill if still running
|
||||
if [ -f "$REDIS_PID_FILE" ]; then
|
||||
PID=$(cat $REDIS_PID_FILE)
|
||||
if ps -p $PID > /dev/null 2>&1; then
|
||||
kill -9 $PID 2>/dev/null
|
||||
fi
|
||||
rm -f $REDIS_PID_FILE
|
||||
fi
|
||||
echo -e "${GREEN}Redis server stopped${NC}"
|
||||
|
||||
echo ""
|
||||
if [ $TEST_EXIT_CODE -eq 0 ]; then
|
||||
echo -e "${GREEN}========================================${NC}"
|
||||
echo -e "${GREEN}All tests completed successfully!${NC}"
|
||||
echo -e "${GREEN}========================================${NC}"
|
||||
else
|
||||
echo -e "${RED}========================================${NC}"
|
||||
echo -e "${RED}Some tests failed!${NC}"
|
||||
echo -e "${RED}========================================${NC}"
|
||||
fi
|
||||
|
||||
exit $TEST_EXIT_CODE
|
||||
|
|
@ -0,0 +1,604 @@
|
|||
#!/bin/bash
|
||||
|
||||
# Redis Table Module Testing
|
||||
# Author: Raphael Drai
|
||||
# Email: raphael.drai@gmail.com
|
||||
# Date: October 3, 2025
|
||||
|
||||
# Redis Table Module - Comprehensive Unit Test Suite
|
||||
# Tests all commands, data types, operators, and edge cases
|
||||
|
||||
REDIS_CLI="../../../src/redis-cli"
|
||||
PASSED=0
|
||||
FAILED=0
|
||||
TEST_NUM=0
|
||||
|
||||
# Colors for output
|
||||
RED='\033[0;31m'
|
||||
GREEN='\033[0;32m'
|
||||
YELLOW='\033[1;33m'
|
||||
NC='\033[0m' # No Color
|
||||
|
||||
# Test helper functions
|
||||
test_start() {
|
||||
TEST_NUM=$((TEST_NUM + 1))
|
||||
echo -e "\n${YELLOW}Test $TEST_NUM: $1${NC}"
|
||||
}
|
||||
|
||||
assert_equals() {
|
||||
local expected="$1"
|
||||
local actual="$2"
|
||||
local test_name="$3"
|
||||
|
||||
if [ "$actual" == "$expected" ]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: $test_name"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: $test_name"
|
||||
echo " Expected: $expected"
|
||||
echo " Actual: $actual"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
}
|
||||
|
||||
assert_contains() {
|
||||
local substring="$1"
|
||||
local actual="$2"
|
||||
local test_name="$3"
|
||||
|
||||
if [[ "$actual" == *"$substring"* ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: $test_name"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: $test_name"
|
||||
echo " Expected to contain: $substring"
|
||||
echo " Actual: $actual"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
}
|
||||
|
||||
assert_error() {
|
||||
local expected_error="$1"
|
||||
local actual="$2"
|
||||
local test_name="$3"
|
||||
|
||||
if [[ "$actual" == *"$expected_error"* ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: $test_name"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: $test_name"
|
||||
echo " Expected error: $expected_error"
|
||||
echo " Actual: $actual"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
}
|
||||
|
||||
# Start tests
|
||||
echo "========================================"
|
||||
echo "Redis Table Module - Unit Test Suite"
|
||||
echo "========================================"
|
||||
|
||||
# Clean slate
|
||||
$REDIS_CLI FLUSHALL > /dev/null
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 1: Namespace Management
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 1: Namespace Management ===${NC}"
|
||||
|
||||
test_start "Create namespace"
|
||||
result=$($REDIS_CLI TABLE.NAMESPACE.CREATE testdb)
|
||||
assert_equals "OK" "$result" "Namespace creation should return OK"
|
||||
|
||||
test_start "Create duplicate namespace"
|
||||
result=$($REDIS_CLI TABLE.NAMESPACE.CREATE testdb 2>&1)
|
||||
assert_error "namespace already exists" "$result" "Duplicate namespace should fail"
|
||||
|
||||
test_start "View namespaces (empty before tables created)"
|
||||
result=$($REDIS_CLI TABLE.NAMESPACE.VIEW)
|
||||
# At this point, no tables exist yet, so result may be empty or show only namespace markers
|
||||
|
||||
test_start "Create table without namespace"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.CREATE nodb.users NAME:string 2>&1)
|
||||
assert_error "namespace does not exist" "$result" "Table creation without namespace should fail"
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 2: Table Creation
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 2: Table Creation ===${NC}"
|
||||
|
||||
test_start "Create table with basic types"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.CREATE testdb.users NAME:string AGE:integer)
|
||||
assert_equals "OK" "$result" "Basic table creation"
|
||||
|
||||
test_start "Create table with all types"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.CREATE testdb.employees EMPID:string SALARY:float HIREDATE:date)
|
||||
assert_equals "OK" "$result" "Table with all data types"
|
||||
|
||||
test_start "Create table with explicit index control"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.CREATE testdb.products NAME:string:true PRICE:float:false STOCK:integer:false)
|
||||
assert_equals "OK" "$result" "Table with explicit index control"
|
||||
|
||||
test_start "Create duplicate table"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.CREATE testdb.users EMAIL:string 2>&1)
|
||||
assert_error "table schema already exists" "$result" "Duplicate table should fail"
|
||||
|
||||
test_start "Create table with invalid format"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.CREATE testdb.bad COL1 2>&1)
|
||||
assert_error "format:" "$result" "Invalid column format should fail"
|
||||
|
||||
test_start "View all namespace tables"
|
||||
result=$($REDIS_CLI TABLE.NAMESPACE.VIEW)
|
||||
assert_contains "testdb:users" "$result" "Should show testdb:users"
|
||||
assert_contains "testdb:employees" "$result" "Should show testdb:employees"
|
||||
assert_contains "testdb:products" "$result" "Should show testdb:products"
|
||||
|
||||
test_start "View specific namespace (testdb)"
|
||||
result=$($REDIS_CLI TABLE.NAMESPACE.VIEW testdb)
|
||||
assert_contains "testdb:users" "$result" "Filtered view should show testdb:users"
|
||||
assert_contains "testdb:employees" "$result" "Filtered view should show testdb:employees"
|
||||
|
||||
test_start "View non-existent namespace"
|
||||
result=$($REDIS_CLI TABLE.NAMESPACE.VIEW nonexistent)
|
||||
if [[ "$result" == *"(empty"* ]] || [[ -z "$result" ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Non-existent namespace returns empty"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Non-existent namespace should return empty"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 3: Table Schema Viewing
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 3: Table Schema Viewing ===${NC}"
|
||||
|
||||
test_start "View table schema"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.VIEW testdb.users)
|
||||
assert_contains "NAME" "$result" "Table schema view should show column names"
|
||||
assert_contains "string" "$result" "Table schema view should show types"
|
||||
assert_contains "true" "$result" "Table schema view should show index status"
|
||||
|
||||
test_start "View non-existent table schema"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.VIEW testdb.notexist 2>&1)
|
||||
assert_error "table schema does not exist" "$result" "View non-existent table should fail"
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 4: Data Insertion
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 4: Data Insertion ===${NC}"
|
||||
|
||||
test_start "Insert basic row"
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.users NAME=John AGE=30)
|
||||
assert_equals "1" "$result" "First insert should return ID 1"
|
||||
|
||||
test_start "Insert second row"
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.users NAME=Jane AGE=25)
|
||||
assert_equals "2" "$result" "Second insert should return ID 2"
|
||||
|
||||
test_start "Insert with integer validation"
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.users NAME=Bob AGE=abc 2>&1)
|
||||
assert_error "invalid column or type" "$result" "Invalid integer should fail"
|
||||
|
||||
test_start "Insert with float type"
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.employees EMPID=E001 SALARY=50000.50 HIREDATE=2020-01-15)
|
||||
assert_equals "1" "$result" "Insert with float"
|
||||
|
||||
test_start "Insert with invalid float"
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.employees EMPID=E002 SALARY=50.00.00 HIREDATE=2020-01-15 2>&1)
|
||||
assert_error "invalid column or type" "$result" "Invalid float should fail"
|
||||
|
||||
test_start "Insert with date type"
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.employees EMPID=E003 SALARY=60000 HIREDATE=2021-03-20)
|
||||
# ID might be 2 or 3 depending on previous failed inserts, just check it's a number
|
||||
if [[ "$result" =~ ^[0-9]+$ ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Insert with date"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Insert with date (got: $result)"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
test_start "Insert with invalid date format"
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.employees EMPID=E004 SALARY=55000 HIREDATE=2021/03/20 2>&1)
|
||||
assert_error "invalid column or type" "$result" "Invalid date format should fail"
|
||||
|
||||
test_start "Insert with invalid date length"
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.employees EMPID=E005 SALARY=55000 HIREDATE=21-03-20 2>&1)
|
||||
assert_error "invalid column or type" "$result" "Invalid date length should fail"
|
||||
|
||||
test_start "Insert with non-existent column"
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.users NOTEXIST=value 2>&1)
|
||||
assert_error "invalid column or type" "$result" "Non-existent column should fail"
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 5: Data Selection - Basic
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 5: Data Selection - Basic ===${NC}"
|
||||
|
||||
test_start "Select all rows"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users)
|
||||
assert_contains "John" "$result" "Select all should return John"
|
||||
assert_contains "Jane" "$result" "Select all should return Jane"
|
||||
|
||||
test_start "Select with equality on indexed column"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE NAME=John)
|
||||
assert_contains "John" "$result" "Equality search should find John"
|
||||
|
||||
test_start "Select with equality on non-indexed column"
|
||||
$REDIS_CLI TABLE.SCHEMA.CREATE testdb.test COL1:string:false > /dev/null
|
||||
$REDIS_CLI TABLE.INSERT testdb.test COL1=value1 > /dev/null
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.test WHERE COL1=value1 2>&1)
|
||||
assert_error "search cannot be done on non-indexed column" "$result" "Equality on non-indexed should fail"
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 6: Comparison Operators
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 6: Comparison Operators ===${NC}"
|
||||
|
||||
test_start "Greater than operator (integer)"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE AGE\>25)
|
||||
assert_contains "John" "$result" "AGE>25 should find John (30)"
|
||||
|
||||
test_start "Less than operator (integer)"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE AGE\<30)
|
||||
assert_contains "Jane" "$result" "AGE<30 should find Jane (25)"
|
||||
|
||||
test_start "Greater than or equal (integer)"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE AGE\>=30)
|
||||
assert_contains "John" "$result" "AGE>=30 should find John"
|
||||
|
||||
test_start "Less than or equal (integer)"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE AGE\<=25)
|
||||
assert_contains "Jane" "$result" "AGE<=25 should find Jane"
|
||||
|
||||
test_start "Greater than operator (float)"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.employees WHERE SALARY\>55000)
|
||||
assert_contains "E003" "$result" "SALARY>55000 should find E003"
|
||||
|
||||
test_start "Less than or equal (float)"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.employees WHERE SALARY\<=50000.50)
|
||||
assert_contains "E001" "$result" "SALARY<=50000.50 should find E001"
|
||||
|
||||
test_start "Greater than operator (date)"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.employees WHERE HIREDATE\>2020-12-31)
|
||||
assert_contains "E003" "$result" "HIREDATE>2020-12-31 should find E003"
|
||||
|
||||
test_start "Less than operator (date)"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.employees WHERE HIREDATE\<2021-01-01)
|
||||
assert_contains "E001" "$result" "HIREDATE<2021-01-01 should find E001"
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 7: Logical Operators
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 7: Logical Operators ===${NC}"
|
||||
|
||||
# Insert more test data
|
||||
$REDIS_CLI TABLE.INSERT testdb.users NAME=Bob AGE=35 > /dev/null
|
||||
$REDIS_CLI TABLE.INSERT testdb.users NAME=Alice AGE=28 > /dev/null
|
||||
|
||||
test_start "AND operator"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE AGE\>25 AND AGE\<35)
|
||||
assert_contains "John" "$result" "AND condition should find John (30)"
|
||||
assert_contains "Alice" "$result" "AND condition should find Alice (28)"
|
||||
|
||||
test_start "OR operator"
|
||||
# Need to add index to AGE first for OR to work with equality
|
||||
$REDIS_CLI TABLE.SCHEMA.ALTER testdb.users ADD INDEX AGE > /dev/null 2>&1
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE AGE=25 OR AGE=35)
|
||||
assert_contains "Jane" "$result" "OR condition should find Jane (25)"
|
||||
assert_contains "Bob" "$result" "OR condition should find Bob (35)"
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 8: Table Alteration
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 8: Table Alteration ===${NC}"
|
||||
|
||||
test_start "Add column with index"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.ALTER testdb.users ADD COLUMN EMAIL:string:true)
|
||||
assert_equals "OK" "$result" "Add indexed column"
|
||||
|
||||
test_start "Add column without index"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.ALTER testdb.users ADD COLUMN CITY:string:false)
|
||||
assert_equals "OK" "$result" "Add non-indexed column"
|
||||
|
||||
test_start "Add index to existing column"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.ALTER testdb.users ADD INDEX AGE)
|
||||
assert_equals "OK" "$result" "Add index to existing column"
|
||||
|
||||
test_start "Verify index was added"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE AGE=30)
|
||||
assert_contains "John" "$result" "Indexed column should now support equality search"
|
||||
|
||||
test_start "Add index to non-existent column"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.ALTER testdb.users ADD INDEX NOTEXIST 2>&1)
|
||||
assert_error "column does not exist" "$result" "Add index to non-existent column should fail"
|
||||
|
||||
test_start "Drop index"
|
||||
result=$($REDIS_CLI TABLE.SCHEMA.ALTER testdb.users DROP INDEX AGE)
|
||||
assert_equals "OK" "$result" "Drop index"
|
||||
|
||||
test_start "Verify index was dropped"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE AGE=30 2>&1)
|
||||
assert_error "search cannot be done on non-indexed column" "$result" "Dropped index should not support equality"
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 9: Data Update
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 9: Data Update ===${NC}"
|
||||
|
||||
test_start "Update with WHERE clause"
|
||||
result=$($REDIS_CLI TABLE.UPDATE testdb.users WHERE NAME=John SET AGE=31)
|
||||
assert_equals "1" "$result" "Update should return count 1"
|
||||
|
||||
test_start "Verify update"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE NAME=John)
|
||||
assert_contains "31" "$result" "Updated value should be 31"
|
||||
|
||||
test_start "Update multiple rows"
|
||||
result=$($REDIS_CLI TABLE.UPDATE testdb.users WHERE AGE\>30 SET AGE=40)
|
||||
updated_count=$(echo "$result" | grep -o '[0-9]\+')
|
||||
if [ "$updated_count" -ge 1 ]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Update multiple rows"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Update multiple rows"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
test_start "Update with invalid type"
|
||||
result=$($REDIS_CLI TABLE.UPDATE testdb.users WHERE NAME=Jane SET AGE=notanumber 2>&1)
|
||||
assert_error "invalid column or type" "$result" "Update with invalid type should fail"
|
||||
|
||||
test_start "Update without WHERE (update by indexed column)"
|
||||
# Update requires WHERE clause, so use an indexed column
|
||||
result=$($REDIS_CLI TABLE.UPDATE testdb.employees WHERE EMPID=E001 SET SALARY=70000)
|
||||
# Check if result is a number (count of updated rows)
|
||||
if [[ "$result" =~ ^[0-9]+$ ]] && [ "$result" -ge 1 ]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Update by indexed column (updated: $result)"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Update by indexed column (got: $result)"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 10: Data Deletion
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 10: Data Deletion ===${NC}"
|
||||
|
||||
test_start "Delete with WHERE clause"
|
||||
result=$($REDIS_CLI TABLE.DELETE testdb.users WHERE NAME=Bob)
|
||||
# Bob might have been updated in previous tests, so just check it's a number
|
||||
deleted_count=$(echo "$result" | grep -o '[0-9]\+' | head -1)
|
||||
if [ -n "$deleted_count" ] && [ "$deleted_count" -ge 1 ]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Delete should return count >= 1"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Delete should return count >= 1 (got: $deleted_count)"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
test_start "Verify deletion"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE NAME=Bob)
|
||||
if [[ "$result" == *"(empty"* ]] || [[ -z "$result" ]] || [[ "$result" == *"(nil)"* ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Deleted row should not exist"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Deleted row should not exist"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
test_start "Delete with comparison operator"
|
||||
result=$($REDIS_CLI TABLE.DELETE testdb.users WHERE AGE\>35)
|
||||
deleted_count=$(echo "$result" | grep -o '[0-9]\+')
|
||||
if [ "$deleted_count" -ge 0 ]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Delete with comparison"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Delete with comparison"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 11: Table Drop
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 11: Table Drop ===${NC}"
|
||||
|
||||
test_start "Drop table without FORCE parameter (should fail)"
|
||||
result=$($REDIS_CLI TABLE.DROP testdb.products 2>&1)
|
||||
assert_error "This operation is irreversible, use FORCE parameter to remove the table" "$result" "Drop without FORCE should fail"
|
||||
|
||||
test_start "Verify table still exists after failed drop"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.products)
|
||||
if [[ "$result" != *"ERR"* ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Table still exists after failed drop"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Table should still exist after failed drop"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
test_start "Drop table with invalid parameter"
|
||||
result=$($REDIS_CLI TABLE.DROP testdb.products INVALID 2>&1)
|
||||
assert_error "Invalid parameter. Use FORCE to confirm table removal" "$result" "Drop with invalid parameter should fail"
|
||||
|
||||
test_start "Drop table with FORCE parameter"
|
||||
result=$($REDIS_CLI TABLE.DROP testdb.products FORCE)
|
||||
assert_equals "OK" "$result" "Drop table with FORCE should return OK"
|
||||
|
||||
test_start "Verify table dropped"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.products 2>&1)
|
||||
assert_error "table schema does not exist" "$result" "Dropped table should not exist"
|
||||
|
||||
test_start "Drop non-existent table with FORCE"
|
||||
result=$($REDIS_CLI TABLE.DROP testdb.notexist FORCE 2>&1)
|
||||
assert_error "table schema does not exist" "$result" "Drop non-existent table should fail"
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 12: Edge Cases
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 12: Edge Cases ===${NC}"
|
||||
|
||||
test_start "Insert with negative integer"
|
||||
$REDIS_CLI TABLE.SCHEMA.CREATE testdb.numbers VALUE:integer > /dev/null
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.numbers VALUE=-42)
|
||||
assert_equals "1" "$result" "Negative integer should work"
|
||||
|
||||
test_start "Insert with negative float"
|
||||
$REDIS_CLI TABLE.SCHEMA.CREATE testdb.floats VALUE:float > /dev/null
|
||||
result=$($REDIS_CLI TABLE.INSERT testdb.floats VALUE=-123.45)
|
||||
assert_equals "1" "$result" "Negative float should work"
|
||||
|
||||
test_start "String comparison operators"
|
||||
$REDIS_CLI TABLE.SCHEMA.CREATE testdb.strings NAME:string:false > /dev/null
|
||||
$REDIS_CLI TABLE.INSERT testdb.strings NAME=Alice > /dev/null
|
||||
$REDIS_CLI TABLE.INSERT testdb.strings NAME=Bob > /dev/null
|
||||
$REDIS_CLI TABLE.INSERT testdb.strings NAME=Charlie > /dev/null
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.strings WHERE NAME\>Bob)
|
||||
assert_contains "Charlie" "$result" "String comparison should work"
|
||||
|
||||
test_start "Empty WHERE clause (returns empty result)"
|
||||
# WHERE without condition returns empty array - this is actually valid behavior
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE 2>&1)
|
||||
if [[ "$result" == *"(empty"* ]] || [[ -z "$result" ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Empty WHERE returns empty result"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Empty WHERE should return empty (got: $result)"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
test_start "Dangling operator"
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE NAME=John AND 2>&1)
|
||||
assert_error "dangling operator" "$result" "Dangling AND should fail"
|
||||
|
||||
test_start "Invalid condition format"
|
||||
# Test with a condition that has no operator
|
||||
result=$($REDIS_CLI TABLE.SELECT testdb.users WHERE InvalidCondition 2>&1)
|
||||
if [[ "$result" == *"ERR"* ]] || [[ "$result" == *"condition"* ]] || [[ -z "$result" ]] || [[ "$result" == *"(empty"* ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Invalid condition format handled"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Invalid condition should fail or return empty (got: $result)"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 13: Help Command
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 13: Help Command ===${NC}"
|
||||
|
||||
test_start "TABLE.HELP command"
|
||||
result=$($REDIS_CLI TABLE.HELP)
|
||||
assert_contains "TABLE.SCHEMA.CREATE" "$result" "Help should contain TABLE.SCHEMA.CREATE"
|
||||
assert_contains "TABLE.SELECT" "$result" "Help should contain TABLE.SELECT"
|
||||
assert_contains "TABLE.INSERT" "$result" "Help should contain TABLE.INSERT"
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 14: Index Maintenance
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 14: Index Maintenance ===${NC}"
|
||||
|
||||
$REDIS_CLI FLUSHALL > /dev/null
|
||||
$REDIS_CLI TABLE.NAMESPACE.CREATE idxtest > /dev/null
|
||||
$REDIS_CLI TABLE.SCHEMA.CREATE idxtest.data NAME:string:true VALUE:integer:true > /dev/null
|
||||
|
||||
test_start "Insert creates index entries"
|
||||
$REDIS_CLI TABLE.INSERT idxtest.data NAME=Test VALUE=100 > /dev/null
|
||||
result=$($REDIS_CLI SMEMBERS "idx:idxtest.data:NAME:Test")
|
||||
assert_contains "1" "$result" "Index should contain row ID"
|
||||
|
||||
test_start "Update maintains indexes"
|
||||
$REDIS_CLI TABLE.UPDATE idxtest.data WHERE NAME=Test SET NAME=Updated > /dev/null
|
||||
result=$($REDIS_CLI SMEMBERS "idx:idxtest.data:NAME:Updated")
|
||||
assert_contains "1" "$result" "Updated index should contain row ID"
|
||||
|
||||
old_index=$($REDIS_CLI SMEMBERS "idx:idxtest.data:NAME:Test")
|
||||
if [[ -z "$old_index" ]] || [[ "$old_index" == *"(empty"* ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Old index entry removed"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Old index entry should be removed"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
test_start "Delete removes index entries"
|
||||
$REDIS_CLI TABLE.DELETE idxtest.data WHERE NAME=Updated > /dev/null
|
||||
result=$($REDIS_CLI SMEMBERS "idx:idxtest.data:NAME:Updated")
|
||||
if [[ -z "$result" ]] || [[ "$result" == *"(empty"* ]]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: Index entry removed after delete"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Index entry should be removed"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
# ============================================
|
||||
# TEST SUITE 15: Complex Scenarios
|
||||
# ============================================
|
||||
echo -e "\n${YELLOW}=== TEST SUITE 15: Complex Scenarios ===${NC}"
|
||||
|
||||
$REDIS_CLI FLUSHALL > /dev/null
|
||||
$REDIS_CLI TABLE.NAMESPACE.CREATE company > /dev/null
|
||||
$REDIS_CLI TABLE.SCHEMA.CREATE company.employees EMPID:string:true NAME:string:true DEPT:string:true SALARY:float:false AGE:integer:false HIREDATE:date:true > /dev/null
|
||||
|
||||
test_start "Complex scenario: Insert multiple employees"
|
||||
$REDIS_CLI TABLE.INSERT company.employees EMPID=E001 NAME=John DEPT=Engineering SALARY=50000.50 AGE=30 HIREDATE=2020-01-15 > /dev/null
|
||||
$REDIS_CLI TABLE.INSERT company.employees EMPID=E002 NAME=Jane DEPT=Marketing SALARY=55000.75 AGE=28 HIREDATE=2021-03-20 > /dev/null
|
||||
$REDIS_CLI TABLE.INSERT company.employees EMPID=E003 NAME=Bob DEPT=Engineering SALARY=60000.00 AGE=35 HIREDATE=2019-06-10 > /dev/null
|
||||
$REDIS_CLI TABLE.INSERT company.employees EMPID=E004 NAME=Alice DEPT=Sales SALARY=58000.25 AGE=32 HIREDATE=2020-11-05 > /dev/null
|
||||
result=$($REDIS_CLI TABLE.SELECT company.employees)
|
||||
row_count=$(echo "$result" | grep -o "EMPID" | wc -l)
|
||||
if [ "$row_count" -eq 4 ]; then
|
||||
echo -e "${GREEN}✓ PASS${NC}: All 4 employees inserted"
|
||||
PASSED=$((PASSED + 1))
|
||||
else
|
||||
echo -e "${RED}✗ FAIL${NC}: Expected 4 employees, got $row_count"
|
||||
FAILED=$((FAILED + 1))
|
||||
fi
|
||||
|
||||
test_start "Complex query: Department + Age range"
|
||||
result=$($REDIS_CLI TABLE.SELECT company.employees WHERE DEPT=Engineering AND AGE\>28)
|
||||
assert_contains "John" "$result" "Should find John in Engineering with AGE>28"
|
||||
assert_contains "Bob" "$result" "Should find Bob in Engineering with AGE>28"
|
||||
|
||||
test_start "Complex query: Salary range"
|
||||
result=$($REDIS_CLI TABLE.SELECT company.employees WHERE SALARY\>=55000 AND SALARY\<=60000)
|
||||
assert_contains "Jane" "$result" "Should find Jane with salary in range"
|
||||
assert_contains "Alice" "$result" "Should find Alice with salary in range"
|
||||
|
||||
test_start "Complex query: Date range"
|
||||
result=$($REDIS_CLI TABLE.SELECT company.employees WHERE HIREDATE\>=2020-01-01 AND HIREDATE\<=2020-12-31)
|
||||
assert_contains "John" "$result" "Should find John hired in 2020"
|
||||
assert_contains "Alice" "$result" "Should find Alice hired in 2020"
|
||||
|
||||
test_start "Add index and query"
|
||||
$REDIS_CLI TABLE.SCHEMA.ALTER company.employees ADD INDEX AGE > /dev/null
|
||||
result=$($REDIS_CLI TABLE.SELECT company.employees WHERE AGE=30)
|
||||
assert_contains "John" "$result" "Indexed AGE query should work"
|
||||
|
||||
test_start "Update salary and verify"
|
||||
$REDIS_CLI TABLE.UPDATE company.employees WHERE EMPID=E001 SET SALARY=52000.75 > /dev/null
|
||||
result=$($REDIS_CLI TABLE.SELECT company.employees WHERE EMPID=E001)
|
||||
assert_contains "52000.75" "$result" "Salary should be updated"
|
||||
|
||||
# ============================================
|
||||
# Final Summary
|
||||
# ============================================
|
||||
echo ""
|
||||
echo "========================================"
|
||||
echo "Test Summary"
|
||||
echo "========================================"
|
||||
echo -e "${GREEN}Passed: $PASSED${NC}"
|
||||
echo -e "${RED}Failed: $FAILED${NC}"
|
||||
echo "Total: $((PASSED + FAILED))"
|
||||
echo "========================================"
|
||||
|
||||
if [ $FAILED -eq 0 ]; then
|
||||
echo -e "${GREEN}All tests passed!${NC}"
|
||||
exit 0
|
||||
else
|
||||
echo -e "${RED}Some tests failed!${NC}"
|
||||
exit 1
|
||||
fi
|
||||
Loading…
Reference in New Issue