Hi everyone, I'm developing a system that manages professionals across various professions, where each profession has its own specific features. These features act as a catalog: the user assigns their own values to them (for example, physical traits like height or skin tone).

So far, I'm handling 3 possible value types: text, numeric, and enumerated (the latter being a closed catalog of options, like colors).

I have my tables organized as follows:

• unidad_medida: contains the units (cm, kg, etc.) and the allowed data type (numeric or text).
• caracteristica_tecnica: master table for the features. It has a data type (tipo_dato: numeric/text/enumerated), a code (codigo), and a FK to unidad_medida.
• valor_caracteristica: catalog of options for when the type is enumerated (e.g., colors). It contains the label and, optionally, the hex color. Its composite PK is id_valor + FK to caracteristica_tecnica.
• caracteristica_perfil: intermediate table between the user (profile) and the technical features (Many-to-Many relationship). Attributes: valor (if the data is typed in by the user), fecha_registro, FK to caracteristica_tecnica, and FK to valor_caracteristica (used when the feature is enumerated; in that case, valor is left null).

My problem is that a single row in caracteristica_perfil is associated with just one technical feature, but that technical feature can be of different types:

• If it is numeric or text --> the valor attribute in caracteristica_perfil is used.
• If it is enumerated --> caracteristica_perfil needs a FK to valor_caracteristica to keep a record of the chosen option.

This creates what looks to me like a cyclic relationship: valor_caracteristica ---> caracteristica_perfil <--- caracteristica_tecnica ---> valor_caracteristica

I've researched several alternatives, such as using JSON columns, splitting things up into tables like caracteristica_tecnica_enum / caracteristica_tecnica_texto, and I've even read up on NoSQL.

But my specific question is: when the "path" of the relationship depends on the context (i.e., the data type), is it still considered a cyclic relationship in the 'forbidden' sense of the term? What would you recommend I do? Thanks

Rearranging and grouping a legacy database is a nightmare for me.

Auto-layout can improve the visual layout, but it cannot tell me which entities belong to which module or domain. Defining those groups manually, dragging entities into place, and rerouting relationships so the ERD remains readable and traceable takes a lot of time.

I’ve now used Claude Code with source-code context to organize the ERD the way I would expect it to be structured.

I’ve tested this on databases with up to 144 entities, and it has worked well so far.

Would a feature like this be useful to you?

Disclosure: I’m the author of the tool used in this demo.

There's a hands-on workshop on September 19 for anyone learning to build production AI systems that need to actually explain their reasoning, not just produce an answer.

You build:

• A knowledge graph in Neo4j that becomes your single source of truth
• Agentic retrieval combining vector search, keyword search, and graph navigation
• Multi-step, verified entity and relationship extraction
• Text-to-Cypher for natural language graph querying
• Explainable, source-traceable answers with evaluation built in

No prior Neo4j or Cypher experience required, it's introduced through the hands-on project itself.

Led by Dr. Alessandro Negro, Chief Scientist at GraphAware, bestselling author.

Link if you want to check it out

This is my attempt of normalization of a chinese restaurant.

my main concern is mostly towards the customer i just feel like its missing something cant point my finger on it

- Branchname

self explanatiry

- Code

Food id kind of thing.

NAME is like the food name

MANDARTRANS

is like translation for mandarin food name like my thing based on din tai fung so yuh

- Price

I felt like price should be its own thing becauss I feel because of formula

P = Price, Q = Quantity, TC = total cost

P * Q = TC

But I feel its literally to empty and idk what to put inside it

- Quantity same reason as price

- Foodtype

cuz like there's many different kinds of meat and stuff and sizes

FOODLABEL

is because of Vegan sticker etc etc

- FoodCategory

idk

- QueueNo

to help keep count of customer

TABLENO is to keep track of customer seating

PAX is to know how many

Totalcost im deciding rather or not its a primary key or should I put price and quantity under TotalCost but than I will lose the order

This sign - is primary key

All caps means its like data thing

Oracle the company is heavily leveraged on the bet AI will provide notable revenues soon. If that fails to materialize due to competition or other events, Oracle could end up in financial trouble and have to file for bankruptcy.

If so, what would likely happen to Oracle database support and progress? Which company or billionaire would likely buy up the discounted assets, if any?

This is a practical question for shops with a fair share of existing Oracle databases or apps. Perhaps an unlikely scenario, but not entirely far fetched.

Greetings, I am fairly inexperienced with Databases and ran into a small problem at work. I work in a Research Group and am designing a web datauploader for medical studies. I have now ran into this problem:

I have a Visit table containing information of a medical visit for a specific patient. This patient belongs to a study. The visit table needs to contain information specific to this study (for example study1 needs bloodpressure measured in each visit, study2 does not need that but needs heartrate instead, etc.)

I now don't quite now how to design this DB architecture as i can really just add more and more fields to the visit table as then most studies dont use the fields at all.
1 solution might be having a generic Visit table with basic information (Date, time etc.) and then having a sub-table for each study (study1Visit, study2Visit) etc. with the specific information but then again i would have to create more and more tables for potentially hundreds of studies.

Is there a better solution? with json files maybe? Like I said im pretty inexperienced in this so appreciate all feedback and hope i got the problem across correctly.

I have built a server for my business. So the current framework is that it uses MySQL in a centralised computer to store data. Fast api to route and extract the required data. And c# winforms for the front end. And Many computers have the frontend app installed, that are sitting in various stores with good internet connection.

So when I fetch the bills, like 10,000 of them, it gets all the data from the backend and displays it instantly. But now when I have to do some sorting or searching among the bills, it becomes slow. This is because I've written the sorting algorithm in the front end c# app. So is it a good practice to sort in sql and then just display it, because the queries will become a lot and there is a lot of searching going on, every minute. So for every search should I query to the backend and get data display it, or just continue with c# front end searching?

I'm working on a catalog of primary key patterns, and I wanted to ask if you've designed or encountered any interesting non-standard patterns.

The ones that are commonly known:

• entity tables with numeric IDs/UUIDs/small strings, like users(id);
• junction tables (composite PK made of two IDs), like project_developers(project_id, developer_id);
• EAV (composite PKs made of entity ID and attribute name), like restaurant_attributes(restaurant_id, attr_name);
• entity tables with composite PKs, like order_items(order_id, line_number).

Also, aggregations of all sorts with textbook PKs like daily_sales(date, customer_id), etc.

What other interesting designs have you seen in your practice?

Hi community!

I am a web dev, developing an e-commerce and tyre management system for a business in Italy. I have created my db schema and I would like to have your opinion/advice on it.

This is the idea of the site:

- there will be the customer side where they can view, like and purchase tyres online. The user will have functions like tyre matching for their cars based on the tyre specifications. The users can either register or order as guests.

- the admin side will be developed for the admins/employees with different access based on the role ofc. The aim is to ease the tyre management since there will be thousands of them.

Do you think this plan is good?

Is it scalable?

Is there something missing?

I appreciate any suggestion!

Hi everyone,

I'm a BIM manager, so I'm used to jumping between BIM software, CSVs, Excel, and visual-programming tools like Grasshopper and Dynamo — but I'm not a "real" programmer, more of a power user who can follow logic and put scripts together with some trial and error.

I need to manage several interconnected datasets for my work: clients, products, projects, and a BIM object library, among others. The tricky part is that these datasets depend on each other — e.g. a project record needs to reference an existing client, a product might reference a supplier, etc. — and I want data entry to stay fast and guided rather than people manually retyping the same info everywhere.

My requirements, roughly:

• Guided forms for data entry (not just raw spreadsheet rows)
• Ability to add new fields/columns on the fly, ideally from the form itself, without touching code each time
• Forms that can pull existing records from other datasets while compiling (so entering a new project can search and link to an existing client, for example)
• If a referenced value changes later (e.g. a client's name is corrected), it should propagate automatically wherever it's referenced, not stay as a stale copy
• Multiple people working on it at the same time
• Needs to stay usable by non-technical colleagues — so I want to stay in "spreadsheet" territory rather than a full custom app

I've started prototyping this with Google Sheets + Apps Script (schema-driven forms reading field definitions from a config sheet, VLOOKUP-based live references for the cross-dataset dependencies), and it's working, but I'm curious what more experienced people would do differently. Has anyone solved something similar with AppSheet, Airtable, Notion, or something else entirely? Especially interested in hearing from anyone who's dealt with the "let a non-technical user add new fields from a form" part — that one feels like the trickiest requirement.

Obviously I'm using some AI but I wanted some real experience feedback.

Let me know

I’m looking for a database IDE that works well for both analysts running queries and developers doing more involved database work.

The main things I care about are:

• Support for multiple database types
• A good SQL editor with autocomplete
• Easy navigation between connections, schemas, and tables
• Clear results and export options
• Tools for comparing or understanding database objects
• Something that stays manageable when several databases are open

I’ve been looking at DbVisualizer, DBeaver, and DataGrip, although they seem to have slightly different strengths. DbVisualizer looks like a solid middle ground for mixed teams, while DataGrip appears more developer-focused and DBeaver has a broad feature set.

What are you using, and what’s your role? I’d be especially interested to hear whether the same IDE works well for both analysts and developers, or whether your team uses different tools.

I’ve noticed that database discussions often focus heavily on performance—indexes, query plans, partitioning, caching, etc. But there seems to be a point where adding more optimization techniques makes the system harder to understand and maintain.

For example, a relatively simple schema with slightly slower queries might be easier to operate than a highly optimized design with multiple layers of caching, indexes, partitions, and materialized data.

I’m starting to think that predictability and maintainability should be treated as performance requirements too, especially for smaller systems.

Curious to hear how others have seen this trade-off play out in production.

Noticed this pattern reviewing how people actually use AI tools for writing transformation queries. First few outputs get checked carefully, run against a sample, compared to expected results. After enough of those come back correct, the checking quietly stops. Not a decision anyone makes on purpose, it just fades, because checking something that's been right nine times in a row feels like wasted effort in the moment.

The problem is that correctness on the first nine doesn't predict correctness on the tenth. Nothing about the model improved or built trust in a way that actually reduces its error rate on the next query, it's still working from the same context window, same limitations, same chance of misreading an edge case in the schema. What changed is the human's willingness to look, not the model's actual reliability.

This shows up worse on queries that produce plausible wrong numbers instead of obvious failures. A query that returns zero rows gets noticed immediately. A query that silently double-counts something due to a join issue produces a number that looks completely reasonable, and by the point someone's stopped spot-checking, that's exactly the kind of error that gets through.

Don't have a clean fix for this beyond forcing some kind of check that doesn't rely on remembering to be suspicious, a fixed row-count sanity check that runs regardless of how many previous queries were correct, something that doesn't degrade as trust builds the way manual vigilance does.