NoSQL Databases Overview

PostgreSQL allows users to define their own custom data types, including combining multiple data types into composite types. This provides flexibility close to what is offered by Object-Oriented Databases (OODBs).

Tables in PostgreSQL can inherit properties and behaviors from parent tables. This is similar to inheritance in object-oriented programming, where child classes inherit traits from parent classes. This makes it easier to model hierarchical data relationships.

PostgreSQL supports a powerful SQL query language with advanced features like recursive queries. Recursive queries allow you to traverse hierarchical data structures and perform operations on related records.

PostgreSQL's extensibility allows users to add new data types, operators, and functions. This empowers developers to customize PostgreSQL to meet the specific needs of their applications.

Key-Value Stores store data as simple key-value pairs, like a dictionary. Each key has a unique value associated with it.

Document-Oriented Databases store data as JSON-like documents. These documents can have nested structures and varying schemas, allowing for flexibility in data models.

Column-Family Stores divide data into rows and columns. Each row can have different columns, making it suitable for storing data with evolving structures.

Graph Databases store data as nodes and edges, representing relationships between entities. These relationships are the focus, making them ideal for data with intricate connections.

A type of database that uses a fixed schema and vertical scaling, making it suitable for structured data and transactional applications.

A type of database that uses a flexible schema and horizontal scaling, making it suitable for unstructured data, large volumes, and high availability.

The capability of a database to handle increasing amounts of data by adding more servers to the system.

The capability of a database to handle increasing amounts of data by increasing the resources of a single server.

Data that does not have a predefined structure, making it flexible and adaptable to various formats.

Data that conforms to a predefined structure, making it easy to organize and query.

The lack of consistent design standards across different NoSQL systems makes it difficult for developers to switch between them, and it can be challenging for them to learn how to use them if they are used to structured relational databases.

NoSQL databases often prioritize speed and availability over ensuring that every change is immediately consistent. They usually use eventual consistency, where data is eventually synchronized but might be temporarily inconsistent.

NoSQL databases sometimes make it difficult to perform complex queries that combine data from multiple tables or sources, which is a strength of relational databases.

Because of the flexible nature of NoSQL, data models can vary widely, potentially leading to inconsistent data structures and making it harder to manage data efficiently across the system.

Object-oriented databases are better suited for handling data that has complex relationships and hierarchical structures, such as images, videos, and 3D models.

OODBs are well-suited for multimedia applications due to their ability to store images, videos, and audio directly without needing to break them down into separate components.

Computer-aided design (CAD) and computer-aided manufacturing (CAM) systems benefit from OODBs because they often involve complex data structures like 3D models, drawings, and design elements.

Geographic information systems (GIS) require storing and analyzing spatial data (locations, maps, etc.) which often has complex object relationships.

Ensures all operations in a transaction succeed or none do, preventing partial updates. If any part fails, the system reverts to the initial state.

Guarantees a transaction brings the database from one valid state to another, upholding rules like constraints and triggers.

Ensures transactions operate independently, preventing interference from other transactions. No transaction sees the intermediate states of another.

Guarantees that once a transaction completes, its changes are permanent, even if the system crashes.

RDBMS typically scale by making improvements to the hardware of a single server, such as adding more CPU or memory. This method is not always suitable for applications requiring horizontal scaling, where data is distributed across multiple servers.

RDBMS rely on predefined, rigid schemas. This is problematic when data structures change frequently or when dealing with unstructured data, such as multimedia files or social media posts.

Relational databases can experience performance issues with complex queries involving multiple joins across large tables. This issue can cause slower response times, especially if data isn't properly indexed or normalized, leading to inefficient data access.

RDBMS struggle to handle unstructured data such as documents, images, or videos effectively, as these data types are often difficult to fit into the strict row-and-column structure of relational databases.

Object-relational mapping (ORM) techniques bridge the gap between object-oriented programming and relational databases, allowing developers to map objects to relational tables for efficient data storage and retrieval.

Extending RDBMS with object-oriented features allows organizations to retain the strengths of the relational model, such as powerful SQL querying and data integrity, while integrating some object-oriented concepts. This approach can be useful for applications that require both structured querying and object-oriented flexibility.

Purely object-oriented databases (OODb) offer a more flexible approach to data storage and retrieval, particularly when dealing with complex relationships and hierarchies. However, they may lack the robust querying capabilities and data integrity features of relational databases.

A database specifically designed to store and manage complex objects with features like inheritance, polymorphism, and encapsulation. It can track objects over time and has its own unique identifiers for each object.

A database specifically designed to manage structured data in tables, rows, and columns. It provides a clear way to organize and query information using SQL (Structured Query Language).

A set of properties ensuring data integrity: Atomicity (transactions complete or fail entirely), Consistency (data adheres to rules), Isolation (multiple transactions don't interfere), Durability (data changes are permanent).

A language used to interact with relational databases by defining queries and data manipulation commands. It allows for efficient data analysis and management.

A way to store objects without a traditional database, potentially by using file systems or simpler storage mechanisms.

The process of making data changes permanent and consistent in a database, even if a system failure occurs.

The ability to manage concurrent access to data from multiple users or applications, ensuring consistency and data integrity.