| Bug #118027 | Transform MySQL into a Structure-Aware, Flexible, AI-Compatible Engine with Infinite Grouping, Symbolic Linking, and Loc | ||
|---|---|---|---|
| Submitted: | 22 Apr 6:43 | Modified: | 22 Apr 11:37 |
| Reporter: | Reza Rezaei | Email Updates: | |
| Status: | Verified | Impact on me: | |
| Category: | MySQL Server: Data Types | Severity: | S4 (Feature request) |
| Version: | 10.x (Future Planning / Major Architectu | OS: | Any |
| Assigned to: | CPU Architecture: | Any | |
| Tags: | ai-database, consciousness-ai, dynamic-types, feature-request, group-schema, hardware-acceleration, infinite-nesting, neuron-structure, object-table, symbolic-link, vector-storage | ||
[22 Apr 7:04]
MySQL Verification Team
Hello Reza Rezaei, Thank you for the feature request! regards, Umesh
[22 Apr 10:44]
Laurynas Biveinis
I for one am very interested how MySQL could be transformed into a "consciousness-level data structure" Or, maybe for some "feature requests" there should be some burden of proof placed on the author to show at least some the barest of bones prototype
[22 Apr 11:37]
Reza Rezaei
Thank you Laurynas, and I completely agree. Any serious proposal — especially one that aims to shift the foundations of relational systems — must eventually carry a burden of proof. That’s why this request wasn’t submitted as a vague vision, but rather as a structured continuation of three already verified proposals (#117920, #117899, #117910), each of which incrementally brings MySQL closer to symbolic-level cognition support. The phrase "consciousness-level data structure" isn’t intended as hype. It's shorthand for a system that can: • Store recursively nested symbolic relations • Maintain cross-domain references without rigid joins • Represent neural-weighted graphs with queryable logic • Evolve structure dynamically — like human cognition does I’m currently working on a prototype to demonstrate this. It won’t be full consciousness (of course), but it will simulate: • Neural object storage • Traversable symbolic links with weights • Adaptive memory structures using real MySQL instances This prototype will be shared when ready. I’m also happy to collaborate with anyone at MySQL interested in turning it into something testable within the engine layer. Of course, any kind of cognition here is artificial — but the direction matters. The goal isn’t to simulate human thoughts directly. It’s to build a system that acts based on how human cognition works — using structure, recursion, and symbolic abstraction, not just repetition or logic trees. Most current AI mimics patterns we give it. But this proposal opens the door to giving AI its own cognition pattern — one that is dynamic, self-extending, and queryable at every layer. That’s where MySQL could play a historic role: The transformation comes from shifting away from storing data as a continuous stream tied to IDs, and instead allowing separation across the disk — based on the simple fact that locations, just like numbers, are unique. If data becomes physically unlinkable — yet symbolically traversable — then joins can be based on location logic, not just index algorithms. And that sounds a lot like how human brains work: Do neurons use numbers? Or do they use connections? They expand through space. They index through structure, not just sequence. So yes — your skepticism is valid. But maybe the answer has been hiding in plain sight all along. Warm regards, Reza Rezaei
Description: This feature request proposes a foundational upgrade to MySQL’s architecture by introducing a new `OBJECT` table type with support for infinite-dimensional, recursively nested group schemas and symbolic link-based relationships. The proposal builds directly on three previously accepted feature requests: - #117920 – Dynamic Data Type Hinting - #117899 – Hardware Acceleration for JSON-like Structures - #117910 – Separation of MySQL into Data and Storage Management Layers Together, these verified proposals laid the groundwork for a data structure that is flexible, structured, deeply relational, and scalable across modern requirements such as AI model storage, neural architecture simulation, symbolic reasoning, graph modeling, and even consciousness-level abstraction. This current proposal aims to complete that foundation by answering key open questions in modern database systems: - How can MySQL remain relational while supporting flexible, recursive, and file-aware structures? - How can complex object hierarchies be stored without sacrificing queryability or performance? - How can databases become expressive enough to support neural-level memory or symbolic cognition, while remaining scalable and inspectable? --- The core of the proposal is the introduction of a new native table type: `OBJECT`. Unlike traditional tables, an `OBJECT` is composed of both standard fields and one or more named group schemas — recursive, typed, or dynamic substructures that behave like miniature tables inside the parent record. Each group: - Has its own logical schema (or may be schema-less) - Can contain fields of any type, including other groups - Is addressable, queryable, and joinable independently or as part of the full object Key concepts: - `group_id`, `parent_id`, and `group_type` are used internally to manage logical nesting - Developers can query groups either hierarchically (e.g., `GROUP_PATH`) or by type (`GROUP_TYPE`) - Groups can be dynamically extended and support optional typing via #117920 --- Symbolic links are introduced to replace ID-based joins with hardware-accelerated, location-based references — similar to symbolic links in file systems. These links: - Are bidirectional and use address-based math (not IDs) - Connect any group to any other group or table - Enable graph traversal and join-less querying Symbolic links also allow decoupled storage: - Data blocks can be stored in any order - Resolution is handled by symbolic maps - Links can span across layers, partitions, or even hardware This introduces a location-driven, index-free mechanism that reduces join overhead, enables async traversal, and aligns with modern SSD- and GPU-friendly architectures. --- The `OBJECT` model supports infinite-dimensional nesting — groups can contain groups indefinitely. This allows: - Dynamic expansion of structure across multiple axes - Mixture of typed (schema-defined) and untyped (dynamic) fields - Evolving data systems that grow organically Examples include: - Recursive knowledge graphs - Object memory systems - Modular CMS and simulation data - AI memory banks and symbolic modeling This model enables developers to publish reusable database structures for games, models, datasets, or AI training environments. --- Two new group-level types are introduced: **1. vector group** Stores ordered numeric values, supports symbolic indexing, sparse representation, and GPU-friendly layouts. Example: ```sql CREATE OBJECT TABLE embedding ( name VARCHAR(100), GROUP vector ( index INT, value FLOAT ) ); ``` **2. neuron group** Models neurons with trainable, symbolic weighted connections. Example: ```sql CREATE OBJECT TABLE neuron ( bias FLOAT, activation_function VARCHAR(20), GROUP connections ( LINK TO neuron WITH weight FLOAT ) ); ``` --- Example queries possible with this system: - **Select all files under nested groups:** ```sql SELECT * FROM GROUP_PATH('project.tasks.comments.files') WHERE mime_type = 'application/pdf'; ``` - **Traverse symbolic connections by weight:** ```sql SELECT * FROM GROUP_PATH('neuron.connections') WHERE weight > 0.5; ``` - **Update neural connection strength:** ```sql UPDATE GROUP_PATH('neuron.connections') SET weight = weight - 0.01 WHERE source = 'A' AND target = 'B'; ``` - **Simulate forward pass:** ```sql SELECT SUM(inputs.value * connections.weight + bias) FROM neurons.inputs JOIN neurons.connections ON inputs.source = connections.source WHERE neuron_id = 'neuron_X'; ``` --- This architecture unlocks: - Symbolic neural modeling - Queryable AI systems - File-aware object graphs - Dynamic object memory - Infinite-dimension data flexibility This proposal represents a working proof that databases can evolve beyond traditional storage — becoming cognition-compatible, AI-native, and symbolically structured at their core. --- For direct collaboration or follow-up, I can be reached at: Email: merezarezaei@gmail.com Website: https://merezarezaei.github.io How to repeat: This feature cannot currently be reproduced because it depends on a new `OBJECT` table type and symbolic linking system that does not exist in any MySQL version. However, if implemented, the following use cases would be possible: --- **1. Create a nested object:** ``` CREATE OBJECT TABLE project ( name VARCHAR(255), GROUP tasks ( title VARCHAR(255), GROUP comments ( text TEXT, GROUP files ( filename VARCHAR(255), mime_type VARCHAR(100) ) ) ) ); ``` --- **2. Query deeply nested groups:** ``` SELECT * FROM GROUP_PATH('project.tasks.comments.files') WHERE mime_type = 'application/pdf'; ``` --- **3. Model and traverse neuron structure:** ``` CREATE OBJECT TABLE neuron ( bias FLOAT, activation_function VARCHAR(50), GROUP connections ( LINK TO neuron WITH weight FLOAT ) ); ``` --- **4. Query symbolic weights:** ``` SELECT * FROM neuron.connections WHERE weight > 0.5; ``` --- **5. Update connection weight (training step):** ``` UPDATE neuron.connections SET weight = weight - 0.01 WHERE source = 'A' AND target = 'B'; ``` --- Suggested fix: Implement a new OBJECT table type with recursive group support, symbolic link engine, location-based join system, and support for `vector group` and `neuron group` types. Use location-based indexing and symbolic links as a hardware-aware join alternative. Allow GPU- and async-friendly symbolic traversal. Allow each component to be integrated gradually. Provide SQL functions to traverse and query symbolic paths. This builds directly on #117920, #117899, and #117910.