Sharing & Protection

Sharing: Safe concurrent multi-user execution while preserving consistency.
Protection: Securing data from unauthorized intrusion, and providing resilient system backup and recovery.

4️⃣

Main Characteristics of DB Approach

Self-Describing Nature

Stores a complete directory called a Catalog which holds data definitions, constraints, and structural rules. This descriptive data is known as Meta-data (data about data).

Program-Data Independence

Provides absolute separation between data storage layouts and external application programs. Structural adjustments to data can be seamlessly applied without modifying any associated access code.

Data Abstraction & Multiple Views

Hides low-level technical storage layers via a unified Data Model to deliver clean, custom virtual Views tailored precisely to different roles.

Concurrency Control & OLTP

Guarantees correct operation execution or flawless rollbacks during concurrent multi-user transactions. Powerfully supports highly scalable OLTP (Online Transaction Processing) systems.

Database Systems Summary

Page 2 of 4

BATCH 47 // DATABASE SYSTEMS

DATABASE USERS CLASSIFICATION

GRANT DBA TO admin_user WITH ADMIN OPTION;

COMMIT_TRANSACTION;

5️⃣

Types of Database Users

A) Actors on the Scene

Administrators (DBA)

Supervise access authorization, regulate resource utilization, and perform continuous hardware/software maintenance.

Database Designers

Map and establish data constraints, design structural schemas, and interface directly with system end users.

Analysts & Programmers

Analyze user specifications to design, write, test, and maintain fully optimized custom application programs.

End Users

Access the system via queries, reports, or routine pre-programmed application transactions.

Sub-categories of End Users:

• Casual Users: Query the database occasionally.

• Naïve / Parametric: The largest group; use pre-built "canned transactions" (e.g., app users, bank tellers).

• Sophisticated: Scientists, analysts, and engineers.

• Stand-alone: Manage personal databases with ready-made packages.

B) Workers Behind the Scene

System Designers

Create internal engines, compilers, and core DBMS systems.

Tool Developers

Design performance monitors, graphic interfaces, and modeling tools.

Operators & Maintenance

Supervise physical hardware, OS configurations, and upgrades.

Database Systems Summary

Page 3 of 4

BATCH 47 // DATABASE SYSTEMS

ADVANTAGES & EVOLUTION

ROLLBACK WORK;

ALTER TABLE Users ADD CONSTRAINT pk_id PRIMARY KEY (id);

6️⃣

Advantages of DB Approach

• Controlling Redundancy: Eliminates duplicate data.

• Access Control: Secure, role-based DBA privileges.

• Persistent Object Storage: Native object persistence.

• Efficient Queries: Built-in optimization and Indexes.

• Backup & Recovery: Automated fault logging and system recovery.

• Integrity Constraints: Automatic IDs and foreign keys.

• Standards Enforcement: Unified schemas and report formats.

• Reduced Time: Speeds up app development.

7️⃣

Historical Evolution

1960s-1970s Hierarchical (IBM IMS) & Network Models.

1970s-1980s Relational model proposed by Ted Codd.

1980s-1990s Object-Oriented & Object-Relational systems.

Web Era XML schemas, dynamic pages, HTTP connections.

Modern Era Big Data, Spark, NoSQL, graph databases.

8️⃣

When NOT to Use a DBMS

DBMS systems introduce performance and resource overhead (cost, complexity, generality) and are unsuitable under:

Investment & Complexity

High initial investment costs and static/simple database requirements.

Embedded & Real-time

Limited memory constraints (Embedded) or extreme, real-time speed demands.

Database Systems Summary

Page 4 of 4

External Schema 1 ↔ Conceptual Schema ↔ Internal Schema

4️⃣

Three-Schema Architecture

Proposed to support program-data independence and support multiple concurrent user views:

Level 3 External Level (External Schemas / Views)

User Perception

Describes specific database views tailored precisely to individual user groups, hiding unrelated data elements.

Level 2 Conceptual Level (Conceptual Schema)

System Structure

Describes structure, entities, relationships, data types, and constraints of the entire database for all users without exposing storage details.

Level 1 Internal Level (Internal Schema)

Physical Storage

Uses a physical data model to describe low-level physical storage structures, data record block layouts, and search paths (e.g., indexes).

The Role of Mappings

The process of transforming requests and data between levels: External/Conceptual mapping (translating user views into systemic logical structure) and Conceptual/Internal mapping (aligning logical schemas with physical system storage files).

5️⃣

Data Independence

The key capacity to modify schema configurations at one design layer without altering higher level representations:

Logical Data Independence

The absolute capacity to change the conceptual schema (adding attributes, changing relationships) without having to alter the existing external schemas or external application programs.

Target: Conceptual-to-External

Physical Data Independence

The capacity to alter the internal schema (modifying indexes, reorganizing block files) without making structural changes to the conceptual schema.

Target: Conceptual-to-Internal

Database Systems Summary

Page 2 of 4

BATCH 47 // DATABASE SYSTEMS

LANGUAGES, INTERFACES, UTILITIES

SELECT name, age FROM Students WHERE gpa > 3.5;

6️⃣

DBMS Languages

DDL (Data Definition Language)

Used by DBAs and database designers to specify conceptual schemas and logical database rules.

• SDL: Storage Definition Language (for physical/internal schema specs).

• VDL: View Definition Language (for defining external views).

DML (Data Manipulation Language)

Used for handling actual data lifecycle operations: retrievals, insertions, deletions, and updates.

• High-Level (Declarative): e.g., SQL; set-oriented. Specifies *what* data to get rather than *how* to access it.

• Low-Level (Procedural): Retrieves data one record at a time; requires explicit coding loops.

7️⃣

DBMS Interfaces, Utilities & Data Dictionary

Interfaces

• Stand-alone: Interactive query screens.
• Programmer: Embedded code, APIs (JDBC/ODBC), procedural block codes (PL/SQL).
• User-Friendly: Menus, Forms-based screens, Graphical interfaces, and Natural language search.

Utilities

Essential system helpers supporting operational DB maintenance:

• Data loading/parsing.
• System backups.
• Physical file reorganization.
• Performance monitors.
• Report generation.

Data Dictionary

A central catalog holding crucial structural info:

• Active: Accessed dynamically directly by DBMS software, designers, and administrators.

• Passive: Accessed only by administrators/users.

Database Systems Summary

Page 3 of 4

BATCH 47 // DATABASE SYSTEMS

ARCHITECTURES & SYSTEM CLASSES

SELECT Class FROM DBMS_Classification WHERE type = "Distributed";

8️⃣

DBMS Architectures

Centralized

Combines everything (software, core hardware, applications, and terminal UI processing) into a single centralized server machine.

Two-Tier C/S

Clients query/connect directly with the backend database server using network connections and standard driver APIs (ODBC/JDBC).

Three-Tier C/S

• Presentation: Browser/UI.
• Middle-Tier: Application/Web Server logic.
• Database: Core DBMS storage.

💡 Three-Tier Security Advantage: The intermediate Application Server isolates clients from direct connections to the Database Server, highly protecting sensitive tables from raw network access.

9️⃣

Classification of DBMSs

By Model

• Legacy: Network, Hierarchical.
• Mainstream: Relational, OO, Object-Relational.
• Modern: NoSQL, Key-Value, Document, Graph, XML.

By Users

• Single-user systems.
• Multi-user systems.

By Distribution

• Centralized
• Distributed:
  • - Homogeneous
  • - Heterogeneous
  • - Federated (Multi-DB)

⚡

Quick Exam Checklist

1. Schema vs. State: Schema = Intension (infrequent changes/database layout structural logic); State = Extension (frequently changing datasets).

2. Three-Schema Architecture: Three strict levels (Internal, Conceptual, External) mapped systematically to preserve high levels of data independence.

3. Data Independence: Logical = changing Conceptual schema without modifying External. Physical = changing Internal schema without affecting Conceptual layout.

4. 3-Tier Security: Remember that the intermediate middle Application Server handles database security and prevents direct client-database handshakes.

Database Systems Summary

Page 4 of 4

Specifies the range of valid, legal, or permissible values that can possibly be assigned to a given attribute (e.g., dates, integers, strings).

2️⃣ D

Weak Entity Types

No Primary Key Attribute

Weak entity types cannot be uniquely identified using their own attributes alone. They rely directly on an Owner / Identifying Entity to exist.

Partial Keys & Relationships

Uses a Partial Key to distinguish records related to the exact same owner entity. Connected to owners via an Identifying Relationship.

Database Systems Summary

Page 2 of 4

BATCH 47 // DATABASE SYSTEMS

RELATIONSHIPS & CONSTRAINTS

(min, max) -> min=0 (Partial), min>=1 (Total)

3️⃣

Relationships & Degree

Definitions

• • Relationship: Association between 2+ entities.
• • Relationship Type: Schema-level structure definition.
• • Recursive: Same entity type participates multiple times in different role behaviors (e.g., Supervision).

Degree & Attributes

• • Binary: Connects 2 entities (most common).
• • Ternary: Connects 3 entities.
• • Attributes: Belong directly to relation links rather than individual entities (crucial for M:N relationships).

4️⃣

Structural Constraints

Cardinality Ratio

Specifies maximum participating instances:

• - 1:1 (e.g., Manages)
• - 1:N (e.g., Works For)
• - M:N (e.g., Works On)

Participation

Specifies minimum participating instances:

• - Total: At least 1 (Existence dependent; Double Line).
• - Partial: Optional (Single Line).

(min, max) Notation

Specifies explicit integer constraints on edges:

• - min=0: Partial
• - min≥1: Total
• - max≥1: Exact upper bound limit

Database Systems Summary

Page 3 of 4

BATCH 47 // DATABASE SYSTEMS

ER DIAGRAM NOTATION & EXAM NOTES

Double Oval ⇦ Multivalued

5️⃣

ER Diagram Notation Summary

6️⃣

Important Exam Notes

UML Diagrams

UML Class Diagrams are represented as 3-compartment boxes: Class Name, Attributes, and Operations.

n-ary vs. Binary

A ternary relationship is NOT logically equivalent to three binary relationships. Redundant binary paths must be removed.

Placing Attributes

Attributes of 1:1 or 1:N relations can migrate to participating entities. Attributes of M:N relations must stay on the relationship itself.

Database Systems Summary

Page 4 of 4

5.1 Output Loop & Logical Error:

If testing shows incorrect results, go back to Analysis/Design (Step 1 or 2) to check core logic rules.

Program Core Elements:

Input (المدخلات): Raw starting data needed. Derived from Nouns.

Processing (المعالجة): Transformative steps. Derived from Verbs.

Output (المخرجات): Final desired results. Derived from Nouns.

CS 1301 Launchpad Summary • Page 1 of 2

Lenny Learning Instructional Design

CS 1301 • BATCH 47

Java Core & Execution Engine

Quick Reference Summary Guide • دليل المراجعة السريعة

Unit 2 Summary

4

Key Java Concepts

مميزات جافا

Object-Oriented Programming (OOP):

Groups data (attributes) and actions (methods) together into organizational units called Objects.

Platform Independence (WORA):

"Write-Once, Run-Anywhere". Compiled bytecode runs on any device containing a compatible JVM without modifications.

Security Ecosystem:

Safe execution via automatic memory tracking, strict type checking, and a robust Bytecode Verifier.

4B

Java Editions

إصدارات جافا

Java SE (Standard Edition)

Desktop systems, core libraries, and critical standard APIs.

Java EE (Enterprise Edition)

Large server frameworks, server clusters, and enterprise APIs.

Java ME (Micro Edition)

Embedded chips, mobile, smart cards with scarce hardware resources.

5

The 5 Phases of Java Development

1. Edit: Written in editor. Saved as .java source file.

2. Compile: javac compiler transforms source code file into .class bytecode.

3. Load: Class Loader transfers bytecode into primary system memory (RAM).

4. Verify: Bytecode Verifier validates syntax safety & security limitations.

5. Execute: JVM Interpreter executes bytecode commands on local host CPUs.

6

Java Virtual Machine (JVM)

An abstract execution software engine that translates standard Java bytecodes into local machine codes for hardware execution.

Three Core JVM Elements:

• • Class Loader: Moves bytecode safely to system memory.
• • Bytecode Verifier: Blocks malware and unsafe files.
• • Bytecode Interpreter: Interprets commands for active CPUs.

7

Testing & Debugging

أنواع الأخطاء وتصحيحها

Syntax Errors خطأ نحوي

Breaks Java grammar rules (e.g. missing semicolon). Blocks compilation.

Logical Errors خطأ منطقي

Program compiles & runs, but outputs are incorrect due to flawed program reasoning.

Runtime Errors خطأ أثناء التشغيل

Triggers immediate program crashes (e.g. dividing by zero during execution).

Compiler Errors أخطاء مطابقة

Mismatch checks, e.g. having public class name not match its .java file.

Debugging (التصحيح): Locating, diagnosing, and correcting code syntax or logical execution issues.

ESSENTIAL

CS 1301 Launchpad Summary • Page 2 of 2

Lenny Learning Instructional Design