Advanced Database Systems – SQL & NoSQL Vocabulary

Vocabulary flashcards covering key terms from the lecture on SQL and NoSQL database systems.

Database

A structured system for storing, managing, and retrieving data, along with the logic, rules, and queries that give the data meaning.

DBMS (Database Management System)

Software that lets users create, access, manage, and manipulate databases; serves as an interface between the data and applications.

SQL Database

A relational database that organizes data into tables and is accessed with Structured Query Language (SQL).

NoSQL Database

A non-relational database category designed for scalability and flexibility; includes document, key-value, column-family, and graph models.

Data Model

A blueprint that defines how data is organized, stored, and related inside a database.

Relational Data Model

SQL-based model that represents data in tables with rows and columns, using keys to define relationships and enforcing ACID properties.

Document Data Model

NoSQL model in which information is stored as flexible, self-contained documents (e.g., JSON, BSON, XML).

Table

A two-dimensional structure in a relational database that stores data about an entity; consists of rows and columns.

Row (Record)

A single data entry in a table, representing one instance of the entity.

Column (Attribute)

A field in a table that holds one specific piece of information about every row.

Primary Key

A unique identifier for each row in a table, ensuring entity integrity and fast retrieval.

Foreign Key

A column in one table that references a primary key in another table, creating relationships and enforcing referential integrity.

Normalization

The process of organizing relational data to minimize redundancy and improve integrity.

Update Anomaly

Inconsistent data that occurs when redundant values are not updated uniformly.

Insertion Anomaly

The inability to add data to a table without the presence of other required data.

Deletion Anomaly

Unintended loss of data when deleting other, related data.

First Normal Form (1NF)

A table format where each column holds atomic values and each record is unique.

Second Normal Form (2NF)

1NF plus removal of partial dependency; every non-key attribute depends on the whole primary key.

Third Normal Form (3NF)

2NF plus removal of transitive dependency; non-key attributes depend only on the primary key.

ACID Properties

Set of guarantees (Atomicity, Consistency, Isolation, Durability) that ensure reliable transaction processing in relational databases.

Atomicity

All-or-nothing execution of a transaction; partial changes are rolled back if any part fails.

Consistency

Guarantee that a transaction brings the database from one valid state to another, respecting constraints and rules.

Isolation

Ensures concurrent transactions do not interfere; intermediate states are hidden from other transactions.

Durability

Once committed, transaction changes are permanent and survive system failures.

Key-Value Store

The simplest NoSQL database type that maps unique keys to arbitrary values; works like a dictionary.

Redis

An in-memory, high-performance key-value store often used for caching, real-time leaderboards, and pub/sub messaging.

Amazon DynamoDB

AWS fully managed key-value and document database known for seamless scalability and single-digit millisecond latency.

Redis CLI

Command-line interface for interacting with a Redis server (e.g., SET, GET, DEL, EXISTS commands).

SET (Redis Command)

Stores a string value under a specified key in Redis.

GET (Redis Command)

Retrieves the value associated with a key in Redis.

Document Store

NoSQL database category that stores data as documents; examples include MongoDB and Couchbase.

MongoDB

Popular document store that saves data in BSON format and offers a rich, JSON-like query language.

BSON

Binary JSON format used by MongoDB to store documents efficiently with embedded type information.

Couchbase

Distributed document database and key-value store known for high performance, scalability, and flexible JSON storage.

JSON (JavaScript Object Notation)

Lightweight, human-readable data-interchange format often used for documents in NoSQL databases.

Nested Document

A document that contains another document or array inside it, enabling complex, hierarchical data structures.

Column-Family Store

NoSQL model storing data in column families rather than rows; optimized for large-scale, sparse datasets (e.g., Cassandra).

Graph Database

NoSQL model optimized for storing nodes and edges to represent complex relationships (e.g., Neo4j).

SQL (Structured Query Language)

Standard language for defining, manipulating, and querying relational databases.

Set Theory

Mathematical foundation of the relational model that treats tables as sets of tuples.

Referential Integrity

Rule ensuring foreign keys always refer to valid, existing primary-key values in related tables.

Schema-Less

Characteristic of many NoSQL databases where the data structure can vary between records without predefined tables.

Scalability

Ability of a database system to handle increasing loads by adding resources such as nodes or hardware.

RedisInsight

GUI tool for visualizing, browsing, and managing Redis data and performance analytics.

AWS Management Console

Web-based interface for managing AWS services, including DynamoDB operations.

NoSQL Workbench

Graphical design and modeling tool for building DynamoDB data models and queries.

SDK (Software Development Kit)

Collection of libraries and tools that enable developers to interact programmatically with databases such as Redis or DynamoDB.