Database Design and Implementation A Practical Introduction Using Oracle SQL (Gould H.)（Z-Library）

【One-Line Pitch】 A concise, exercise-driven introduction to relational database design that takes you from drawing entity-relationship diagrams to building working Oracle SQL tables and simple APEX forms. Best for computing students, aspiring database designers/developers, and anyone who commissions database work and wants to understand what they are asking for. 【Book Arc】 - **Opening (~0%–10%)**: Establishes the case for conceptual data modelling and introduces the Entity Relationship Diagram (ERD), entity types, attributes, and the Crow's Foot notation, with UML class diagrams noted as an alternative. Solves the problem of how to represent a system's data needs before touching any software. - **Early (~10%–35%)**: Moves into identifying and validating entities, choosing identifiers, and modelling relationships with cardinality and optionality. Then handles complex situations: link entities for many-to-many relationships that carry data, recursive relationships, sub-types, and exclusive relationships. - **Middle (~35%–55%)**: Translates the conceptual model into a logical design: relations, primary/candidate/compound keys, foreign keys, and the rules for placing keys depending on optionality. Covers one-to-one, one-to-many, and many-to-many resolution, plus identifying dependency relationships. - **Late (~55%–85%)**: Shifts to physical implementation and SQL — data types, creating tables, and using foreign keys to enforce referential integrity. The excerpts do not cover the exact chapter sequence here, but the contents list confirms chapters on "Using Foreign Keys" and SQL. - **Ending (~85%–100%)**: Introduces simple application development using Oracle APEX forms and reports, turning the database into a usable interface. The excerpts do not cover the detailed content of these final chapters. 【Key Takeaways】 - **Conceptual modelling comes first** (Opening): ERDs capture entities, attributes, and relationships before any table is built; changing a model is far cheaper than changing a developed system. - **Entities are nouns, attributes are properties** (Early): Distinguishing entity types from attributes (e.g., CUSTOMER vs. ORDER DATE) is a core skill reinforced by exercises with feedback. - **Every entity needs a unique identifier** (Early): Choosing a reliable identifying attribute — one that is always present and unique — is essential; poor choices like postcode or phone number are explicitly rejected. - **Cardinality and optionality must be read in both directions** (Early): Misreading a relationship leads to wrong foreign key placement; the book stresses labelling relationships clearly to avoid this. - **Many-to-many relationships need a link entity** (Early): When a M:N relationship carries data of interest (e.g., RENTAL between CUSTOMER and HIRE CAR), it must be resolved into an associative entity with its own identifier. - **Foreign key placement depends on optionality** (Middle): If the "one" end is optional, placing the foreign key there creates nulls; instead, a third relation is created to express the relationship safely. - **Logical design follows a methodical process** (Middle): Working from the ERD, checking each relationship in turn, produces skeleton relations with primary and foreign keys — a repeatable technique rather than guesswork. - **SQL implementation uses Oracle as the vehicle** (Late): The book teaches industry-standard SQL through Oracle Database and APEX, with practical exercises; the excerpts do not cover the specific SQL syntax chapters in detail. 【Reading Tips】 - **Deep-read the early modelling chapters (1–3)**: The exercises and feedback are the heart of the book; attempt each one before reading the answer, as the feedback explains why certain choices fail. - **Skim the tool-specific setup**: References to QSEE SuperLite, Oracle 11g Express Edition, and APEX account setup are practical but not conceptual — get them working once, then focus on the modelling and SQL logic. - **Pay special attention to optionality and foreign keys (Middle)**: This is where logical design becomes tricky; the three-relation solution for optional one-to-one and one-to-many cases is a key pattern to internalise. - **Use the summaries and terminology lists as revision aids**: The book includes concise summaries (e.g., entity/relationship terminology) that are useful for quick review before exams or interviews. - **Treat APEX chapters as a bonus, not the core**: The final application development section shows how to build forms and reports, but the book's main value is the design-to-SQL pipeline. 【Coverage Limits】 This guide is based on stratified excerpts covering roughly the first half of the book (conceptual and logical design) plus the table of contents; the SQL implementation and APEX chapters are only lightly represented, so specific syntax and application-building details are not summarised here.