Asynchronous statement cancellation / timeouts
Force any of the following actions: cancel a running statement, rollback a transaction, kill an attachment. Allow setting timeouts for SQL statements. Should be available at least at the API level.
Monitoring via API and/or special tables
Perform a "snapshot" monitoring (i.e. at the given moment) of the internal activities inside the engine. Obvious objects of such a monitoring are: databases, attachments, transactions, active requests, resource (memory, CPU) usage, etc..
Detailed SQL tracing/profiling
Show detailed access path (at the RSB tree level) for every retrieval, count rows (profile CPU time, etc) per every node. Available runtime statistics should be extended.
Allow to log some events happening on the server. These could be: successful/rejected authentification attempts (containing client host info), prepared/executed SQL statements, committed/rolled back transactions, etc. We need API to set up the required events and to retrieve the audit log.
DDL level and global triggers
Allow triggers ON CREATE/ALTER/DROP. Implement triggers attachment and transaction level triggers running in autonomous transactions.
PSQL debugging extensions/hooks
Allow PSQL debugging via introducing: looper breakpoints, handler callbacks, retrieval of context data, etc.
priority = low
complexity = research
Maintenance / Recovery
Reliable logical backup
The only case of unrestorable backup should be a physically corrupted backup. Primitive objects (generators, UDFs, etc) must be restored in the beginning. Computed columns and validation constraints must be restored at the end. The engine should reject inconsistent data instead of transform them when reading (e.g. no value -> NULL). GBAK should allow partial restore, driven by switches or interactively.
The engine must have an optional ability to maintain a redo log in order to roll it over the last logical backup. No data loss is acceptable.
Embedded users / SQL users management
Allow in-database users management. (Done in Vulcan)
User permissions for metadata
Protect all metadata with security classes. Implement metadata-level permissions. Add database-level permissions like BACKUP, DROP, etc.
Pluggable authentication modules
Enable using of custom authentication mechanisms (e.g. native OS ones).
Design group-based security as an alternative to the existing role-based one.
Allow optional encryption of database files. Keys management is an open question here.
Performance / Optimizer
Faster outer joins
Implement the merge algorithm for outer joins.
Fix known bugs/limitations, better optimizer decisions, more data statistics
More effective sorting
Implement partial sorting to spead up FIRST-limited retrievals. Consider sorting recno's instead of entire rows.
Optimized network protocol
Avoid sending a lot of unneeded data (buffer tails). Consider implementing protocol batches (e.g. prepare + info). Compress spaces more effectively.
More access paths
Consider implementation of hash join / hash aggregate and other retrieval algorithms used in the competitor RDBMS.
Temporary tables / transient datasets
Implement temporary schema objects and/or datasets. SQL-99 compliance is required, extensions are welcome. (Partly done in Fyracle.)
More built-in functions
The SQL-99 (or later) ones (those of major importance for us) must be implemented first. Then we need users feedback about other ones.
First, it significantly reduces a cost of the issue with short metadata names. Second, it simplifies administration as a number of different databases could be united into a single file. Third, it finally allows us to be fully SQL-92 (entry level) compliant.
Native long numeric data type
Implement long exact numeric data type (with precision longer than 30 decimal digits) and appropriate BCD arithmetics.
Implement SQL for recursive retrievals. Make it consistent with the SQL specification.
Allow usage of regular expressions in search conditions. Add some special syntax (a new predicate) for this purpose.
TEXT BLOB compatible with [VAR]CHAR
Allow BLOB SUB_TYPE TEXT to be compatible/interchangable with string data types. Allow text blobs in all built-in functions.
Allow usage of domains in PSQL parameters and variables, as well as in the CAST function.
Longer metadata names
Up to 128 unicode characters.
CREATE/ALTER/DROP FUNCTION as per SQL-99.
Implement commit-time constraint checking as per SQL specification.
Generic / Architecture
SMP support in SS
Support effective fine grained multi-threading in the SS architecture. (Done in Vulcan.)
Compiled statements cache
Support caching/reusing of compiled statements. (Partly done in Vulcan)
Allow to create procedures/functions written in non-PSQL languages. Provide a few drivers (cdecl, Java, .NET) in the distros. (Partly done in Fyracle.)
External data sources / database links / cross-database SQL
Allow retrievals from external data sources. Provide a few drivers (native FB, JDBC, ODBC) in the distros. Add DDL to declare and DML to use such sources. Implement optimization of retrievals for native data sources.
Solve the known inconsistencies in verbs/transactions. Mostly, this covers blr_for behaviour in INSERT/UPDATE/DELETE statements. Make read-committed transactions compliant with the SQL specification.
Allow reversed index navigation to use ASC-indices for DESC sorting and vice versa.
Implement effective mass data load ability. Provide utility/syntax to use different input formats (csv, xml schema, etc) for import.
Referential integrity without indices
Implement (optionally) foreign keys that are not enforced by indices. Also provide an ability to reuse the existing index for a constraint.
Implement FTS features inside the engine or add API to plug the external FTS engines in. FB seems to be the only RDBMS that don't have this feature yet.
MySQL supports clusters (AFAIK, only shared-memory so far), PostgreSQL shared-disk implementation is in the way. More and more buzz about this feature around the world.
Consider implementation of scrollable cursors inside the engine or provide a thin layer at the top of the RSB hierarchy to implement the feature via the caching.
Provide at least fetch to XML and insert from XML abilities. Consider having BLOB SUB_TYPE XML and implementing XPath queries.