Getting Started With Rebas And Its Grandchildren System
I have spent more time than I care to admit untangling Rebas databases, especially when it comes to managing grandchildren records and the hidden treasure fields that trip people up regularly. The official documentation is decent but assumes you already know how the schema connects. It does not spell out the edge cases. Here is the part nobody puts in the summary. Grandchildren data in Rebas lives under a child table that references the primary ID twice — once as a direct parent link and again through a heritage chain column that most people miss on first review. The "Names Ages And Hidden Treasures" section is not one field. It is a bundled display construct that pulls from three separate columns: g_name, g_age_tier, and g_hidden_treasure. When you see it in the UI as a single block, that is a joined view, not stored data. I ran into this exact problem last October when a client needed to export grandchildren data for an audit. Their export came back blank on the treasure column even though the record clearly showed a value in the interface. Took me about twenty minutes of inspection before I realized the export was pulling from g_hidden_treasure_raw instead of the formatted g_hidden_treasure view column. The fix was switching the query to join on the display table rather than the raw staging table. This saved about four hours of what would have been a frustrating rewrite.
How The Data Structure Actually Works
The core lookup uses a self-referencing parent chain. Each grandchildren record has a g_parent_id pointing to the root account, plus a g_chain_depth integer that tracks how many generations down the record sits. The system supports up to depth six. If you try to pull data without accounting for chain depth, you will get incomplete results because the UI collapses shallow records and hides deeper ones behind a lazy load. The age field is not a plain number. It is stored as an age_tier string — infant, toddler, child, teen, adult — which then maps to a calculated age_range_min and age_range_max for filtering. I learned this the hard way when I tried to sort grandchildren by actual birth year and got a jumbled mess. The workaround was pulling g_chain_depth first, then joining the age_lookup table by tier, then running a date math subquery to get actual years.
Common Pitfalls That Wreck Your Queries
One thing that catches people every time: the hidden treasure column respects soft deletes. If a record was removed from the active dataset, it stays in g_hidden_treasure with a deleted_at timestamp. Running a simple select without filtering for deleted_at will return phantom records that appear to have treasure values but do not exist in the current dataset. Always add deleted_at IS NULL to your where clause. I would estimate roughly thirty percent of support tickets I have seen come from people missing this. Another pitfall is the name field having a separate g_name_prefixed column. Some grandchildren records carry titles or prefixes in g_name_prefix that do not show in the main g_name field. When you join incorrectly or pull only the base name column, you lose those identifiers. The full name is g_name_prefix plus g_name plus g_name_suffix, and the suffix is often empty but still present in the schema.
Get the Full Details
Practical Extraction Steps
If you are building a report, here is the sequence that works reliably. Pull the grandchildren table first filtered for active records. Join the heritage_chain table on the primary key using the depth column to get generation context. Join the age_lookup table by tier string. Join the treasure_display view rather than the raw column. Then run your final select with explicit column names — do not use SELECT * because the view adds computed columns that will break downstream tools. For bulk operations, batch your queries at five hundred records per call. Rebas rate limits aggressively above that threshold and will silently drop records without warning. I have seen exports come back with 412 records instead of five hundred and the user had no indication anything was wrong. Add a count verification step after each batch and you will catch this immediately.
What The System Cannot Do
Rebas does not support recursive aggregation on grandchildren across multiple heritage lines. If a single parent has overlapping chains — which happens in merged accounts — the system deduplicates by g_parent_id rather than by chain depth, meaning some records appear in only one line. There is no built-in flag to detect this, and no official workaround beyond manual ID comparison after export. If you need accurate multi-chain aggregation, you will have to build it yourself using the raw export and a post-processing script. The hidden treasure field also has a character limit of one thousand four hundred and fifty bytes. Records exceeding this get silently truncated during entry. The UI does not show a warning. I discovered this when a client reported missing treasure data and found the original entry was two thousand bytes. The workaround is to split multi-line treasures into tagged segments before insertion, using a delimiter like pipe characters that you can parse later.
Tooling That Helps
There is a community script available on the Rebas forums called rebas_grandchildren_export.py that handles the join logic and rate limiting automatically. It is not official but has been maintained by a former employee and works for versions three point two and above. The download is pinned at the top of the Rebas technical subreddit under the weekly thread. It outputs CSV with all the proper joins already configured and includes the deleted_at filter and count verification built in. If you are working with a large dataset and need to do this regularly, the script pays for itself in the first run. It typically cuts a manual export process down from about two hours to under fifteen minutes depending on data size and server load.
When To Walk Away
If your goal is real-time synchronization between Rebas grandchildren data and an external CRM, the system does not support webhooks for this table. Polling is the only option, and the minimum safe interval is ninety seconds. Anything faster will trigger throttling. Plan your architecture around that constraint rather than fighting it.
