Add TTL support (EXPIRE, TTL, EXPIREAT) to Redis extension

Adds three scalar functions for managing key time-to-live in Redis:
- redis_expire(key, seconds, secret): Set TTL in seconds, returns TRUE if set
- redis_ttl(key, secret): Get remaining TTL (-2=key not exist, -1=no expiry)
- redis_expireat(key, timestamp, secret): Set expiry at Unix timestamp, returns TRUE

Implementation details:
- Added 4 protocol formatters to RedisProtocol class
- Added parseIntegerResponse() helper for parsing integer responses
- Updated extension version from 2025120401 to 2026011401
- Added error-handling tests for non-existent secrets
- Updated documentation with features, reference table, and usage examples

All functions follow existing patterns and pass unit tests.
Live-tested against local Redis instance - all TTL operations working correctly.

Author: JC1738

docs/README.md

@@ -17,6 +17,7 @@ Currently supported Redis operations:
 - Hash operations: `HGET`, `HSET`, `HGETALL`, `HSCAN`, `HSCAN_OVER_SCAN`
 - List operations: `LPUSH`, `LRANGE`, `LRANGE_TABLE`
 - Key operations: `DEL`, `EXISTS`, `TYPE`, `SCAN`, `KEYS`
+- TTL operations: `EXPIRE`, `TTL`, `EXPIREAT`
 - Batch and discovery operations: `SCAN`, `HSCAN_OVER_SCAN`, `KEYS`
 
 ## Quick Reference: Available Functions
@@ -33,6 +34,9 @@ Currently supported Redis operations:
 | `redis_del(key, secret)` | Scalar | Delete a key (returns TRUE if deleted) |
 | `redis_exists(key, secret)` | Scalar | Check if a key exists (returns TRUE if exists) |
 | `redis_type(key, secret)` | Scalar | Get the type of a key |
+| `redis_expire(key, seconds, secret)` | Scalar | Set TTL in seconds (returns TRUE if set) |
+| `redis_ttl(key, secret)` | Scalar | Get remaining TTL (-2=key not exists, -1=no expiry) |
+| `redis_expireat(key, timestamp, secret)` | Scalar | Set expiry at Unix timestamp (returns TRUE if set) |
 | `redis_scan(cursor, pattern, count, secret)` | Scalar | Scan keys (returns cursor:keys_csv) |
 | `redis_hscan(key, cursor, pattern, count, secret)` | Scalar | Scan fields in a hash |
 | `redis_keys(pattern, secret)` | Table | List all keys matching a pattern |
@@ -157,6 +161,22 @@ SELECT redis_exists('user:1', 'redis');
 SELECT redis_type('user:1', 'redis');
 ```
 
+### TTL Operations
+```sql
+-- Set a key to expire in 1 hour
+SELECT redis_expire('session:123', 3600, 'redis');
+
+-- Check remaining TTL
+SELECT redis_ttl('session:123', 'redis') as remaining_seconds;
+
+-- Set expiry at specific timestamp
+SELECT redis_expireat('cache:item', 1736918400, 'redis');
+
+-- Expire all session keys in a query
+UPDATE sessions
+SET expired = CASE WHEN redis_expire('session:' || id, 300, 'redis') THEN TRUE ELSE FALSE END;
+```
+
 ### Batch and Discovery Operations
 ```sql
 -- Get multiple keys at once

src/redis_extension.cpp

@@ -150,6 +150,31 @@ class RedisProtocol {
 		}
 		return cmd;
 	}
+
+	static std::string formatExpire(const std::string &key, int64_t seconds) {
+		return "*3\r\n$6\r\nEXPIRE\r\n$" + std::to_string(key.length()) + "\r\n" + key + "\r\n$" +
+		       std::to_string(std::to_string(seconds).length()) + "\r\n" + std::to_string(seconds) + "\r\n";
+	}
+
+	static std::string formatExpireAt(const std::string &key, int64_t timestamp) {
+		return "*3\r\n$8\r\nEXPIREAT\r\n$" + std::to_string(key.length()) + "\r\n" + key + "\r\n$" +
+		       std::to_string(std::to_string(timestamp).length()) + "\r\n" + std::to_string(timestamp) + "\r\n";
+	}
+
+	static std::string formatTtl(const std::string &key) {
+		return "*2\r\n$3\r\nTTL\r\n$" + std::to_string(key.length()) + "\r\n" + key + "\r\n";
+	}
+
+	static int64_t parseIntegerResponse(const std::string &response) {
+		if (response.empty() || response[0] != ':') {
+			throw InvalidInputException("Invalid Redis integer response");
+		}
+		size_t end = response.find("\r\n");
+		if (end == std::string::npos) {
+			throw InvalidInputException("Invalid Redis integer response");
+		}
+		return std::stoll(response.substr(1, end - 1));
+	}
 };
 
 // Redis connection class
@@ -845,6 +870,57 @@ static void RedisTypeFunction(DataChunk &args, ExpressionState &state, Vector &r
 	});
 }
 
+static void RedisExpireFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &key_vector = args.data[0];
+	auto &seconds_vector = args.data[1];
+	auto &secret_vector = args.data[2];
+
+	BinaryExecutor::Execute<string_t, int64_t, bool>(
+	    key_vector, seconds_vector, result, args.size(), [&](string_t key, int64_t seconds) {
+		    string host, port, password;
+		    if (!GetRedisSecret(state.GetContext(), secret_vector.GetValue(0).ToString(), host, port, password)) {
+			    throw InvalidInputException("Redis secret not found");
+		    }
+		    auto conn = ConnectionPool::getInstance().getConnection(host, port, password);
+		    auto response = conn->execute(RedisProtocol::formatExpire(key.GetString(), seconds));
+		    auto result_int = RedisProtocol::parseIntegerResponse(response);
+		    return result_int == 1;
+	    });
+}
+
+static void RedisTTLFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &key_vector = args.data[0];
+	auto &secret_vector = args.data[1];
+
+	UnaryExecutor::Execute<string_t, int64_t>(key_vector, result, args.size(), [&](string_t key) {
+		string host, port, password;
+		if (!GetRedisSecret(state.GetContext(), secret_vector.GetValue(0).ToString(), host, port, password)) {
+			throw InvalidInputException("Redis secret not found");
+		}
+		auto conn = ConnectionPool::getInstance().getConnection(host, port, password);
+		auto response = conn->execute(RedisProtocol::formatTtl(key.GetString()));
+		return RedisProtocol::parseIntegerResponse(response);
+	});
+}
+
+static void RedisExpireAtFunction(DataChunk &args, ExpressionState &state, Vector &result) {
+	auto &key_vector = args.data[0];
+	auto &timestamp_vector = args.data[1];
+	auto &secret_vector = args.data[2];
+
+	BinaryExecutor::Execute<string_t, int64_t, bool>(
+	    key_vector, timestamp_vector, result, args.size(), [&](string_t key, int64_t timestamp) {
+		    string host, port, password;
+		    if (!GetRedisSecret(state.GetContext(), secret_vector.GetValue(0).ToString(), host, port, password)) {
+			    throw InvalidInputException("Redis secret not found");
+		    }
+		    auto conn = ConnectionPool::getInstance().getConnection(host, port, password);
+		    auto response = conn->execute(RedisProtocol::formatExpireAt(key.GetString(), timestamp));
+		    auto result_int = RedisProtocol::parseIntegerResponse(response);
+		    return result_int == 1;
+	    });
+}
+
 static void LoadInternal(ExtensionLoader &loader) {
 	// Register the secret functions first!
 	CreateRedisSecretFunctions::Register(loader);
@@ -972,6 +1048,36 @@ static void LoadInternal(ExtensionLoader &loader) {
 	                    "stream) or 'none' if the key does not exist.",
 	                    {"key", "secret_name"}, {"SELECT redis_type('mykey', 'my_redis_secret');"});
 
+	// Register redis_expire scalar function
+	add_scalar_function(
+	    ScalarFunction("redis_expire", {LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::VARCHAR},
+	                   LogicalType::BOOLEAN, RedisExpireFunction),
+	    "Set a time-to-live (TTL) in seconds for a key. Returns true if the TTL was set, false if the key does not exist.",
+	    {"key", "seconds", "secret_name"},
+	    {"SELECT redis_expire('mykey', 3600, 'my_redis_secret');",
+	     "SELECT redis_expire('session:' || id, 300, 'my_redis_secret') FROM users;"});
+
+	// Register redis_ttl scalar function
+	add_scalar_function(ScalarFunction("redis_ttl", {LogicalType::VARCHAR, LogicalType::VARCHAR}, LogicalType::BIGINT,
+	                                   RedisTTLFunction),
+	                    "Get the remaining time-to-live (TTL) of a key in seconds. Returns -2 if the key does not exist, "
+	                    "-1 if the key exists but has no expiry set.",
+	                    {"key", "secret_name"},
+	                    {"SELECT redis_ttl('mykey', 'my_redis_secret');",
+	                     "SELECT key, redis_ttl(key, 'my_redis_secret') FROM (SELECT redis_get(key) as key FROM "
+	                     "redis_keys('*', 'my_redis_secret')); "});
+
+	// Register redis_expireat scalar function
+	add_scalar_function(
+	    ScalarFunction("redis_expireat", {LogicalType::VARCHAR, LogicalType::BIGINT, LogicalType::VARCHAR},
+	                   LogicalType::BOOLEAN, RedisExpireAtFunction),
+	    "Set an expiry time (Unix timestamp) for a key. Returns true if the expiry was set, false if the key does not "
+	    "exist.",
+	    {"key", "timestamp", "secret_name"},
+	    {"SELECT redis_expireat('mykey', 1736918400, 'my_redis_secret');",
+	     "SELECT redis_expireat('event:' || id, EXTRACT(EPOCH FROM (event_time + INTERVAL '1 day'))::BIGINT, "
+	     "'my_redis_secret') FROM events;"});
+
 	// Register redis_keys table function
 	add_table_function(
 	    TableFunction("redis_keys", {LogicalType::VARCHAR, LogicalType::VARCHAR}, RedisKeysFunction, RedisKeysBind),
@@ -1006,7 +1112,7 @@ static void LoadInternal(ExtensionLoader &loader) {
 	    {"scan_pattern", "hscan_pattern", "count", "secret_name"},
 	    {"SELECT * FROM redis_hscan_over_scan('user:*', '*', 100, 'my_redis_secret');"});
 
-	QueryFarmSendTelemetry(loader, "redis", "2025120401");
+	QueryFarmSendTelemetry(loader, "redis", "2026011401");
 }
 
 void RedisExtension::Load(ExtensionLoader &loader) {
@@ -1018,7 +1124,7 @@ std::string RedisExtension::Name() {
 }
 
 std::string RedisExtension::Version() const {
-	return "2025120401";
+	return "2026011401";
 }
 
 } // namespace duckdb

test/sql/redis.test

@@ -87,6 +87,21 @@ SELECT * FROM redis_hscan_over_scan('*', '*', 100, 'nonexistent_secret');
 ----
 Redis secret not found
 
+statement error
+SELECT redis_expire('mykey', 3600, 'nonexistent_secret');
+----
+Redis secret not found
+
+statement error
+SELECT redis_ttl('mykey', 'nonexistent_secret');
+----
+Redis secret not found
+
+statement error
+SELECT redis_expireat('mykey', 1736918400, 'nonexistent_secret');
+----
+Redis secret not found
+
 # Test that we can create a redis secret
 statement ok
 CREATE SECRET my_test_secret (