This thesis investigates a conceptual database architecture in which applications interact with conceptual schemas while the database system manages their relational realization. Such an architecture can provide a common semantic layer for integrating heterogeneous data and supporting relationship-rich applications, including graph analytics and machine-learning pipelines. Realizing this vision requires efficient query execution, workload-aware selection of relational mappings, and efficient database-resident enforcement of conceptual integrity constraints.

Many graph and machine-learning workloads contain queries with many-to-many joins that generate large intermediate results even when their final outputs are small. This intermediate-result explosion can increase memory consumption and execution time and can introduce statistical distortions in machine-learning feature construction. Prior work addresses these challenges through techniques such as worst-case optimal joins, factorized representations, semi-join reduction, and predicate transfer. This thesis studies the cost-based optimization problem underlying the selection among such techniques. We develop a refined cost model that more accurately captures the execution behavior of plans containing many-to-many joins and introduce optimization algorithms that use this model to select effective execution strategies. We integrate these techniques into a modern vectorized execution engine. Our experiments show that the best strategy depends strongly on query structure and data characteristics, demonstrating the need for fully cost-based optimization of many-to-many joins.

We next present a cost-based schema-compilation approach for translating a conceptual schema into an efficient relational realization. Although relational databases provide strong physical data independence, they provide substantially less logical data independence. Decisions about how to represent inheritance hierarchies, polymorphic associations, weak entities, relationships, and multi-valued attributes are typically fixed manually during schema design, even though they can substantially affect performance. We treat these mapping choices as optimization variables and select among them using the conceptual schema, data characteristics, and workload. This makes schema compilation systematic and workload-aware while preserving the application-facing conceptual schema independently
of its relational realization.

Finally, this thesis examines how schema-compilation choices affect integrity enforcement. Semantically equivalent relational realizations of inheritance hierarchies, relationships, and weak entities can differ substantially in the locality and enforceability of their constraints. Constraints that are declarative and local under one mapping may span multiple relations or nested representations under another, requiring specialized enforcement mechanisms. To address such invariants, we develop constraint indexes: specialized, shared in-memory structures that maintain compact constraint state and provide transactional access paths for validation and maintenance.