CHAPTER 02

Data Models and Query

Languages
Relational Model Versus
Document Model
Understanding the Document Model
Documents are self-describing data structures, typically stored Collections are containers for documents. Within the same
in JSON . They provide flexibility in defining fields and their data collection, different documents can have varying fields, allowing
types. for diverse data structures.
 Schema Flexibility in
Document Databases
This presentation will explore the concept of schema flexibility within the
context of document databases. We will analyze the benefits, challenges,
and best practices for implementing flexible schemas in your applications.
Benefits of Schema
Flexibility: Agility and Speed
1 Faster Development 2 Agile Data Modeling
Schema flexibility enables Iterative development is
quicker development cycles, facilitated, allowing for quick
as developers can iterate and adjustments to the data
evolve the data model model based on changing
without complex migrations requirements.
or downtime.

3 Increased Productivity
Studies show that schema-less development can accelerate
development cycles by 20-30%, resulting in faster time-to-market.
Adapting to Change: Evolving
Data Structures
1 New Fields
Adding new fields to documents without affecting existing data
allows for seamless evolution of the data model.

2 Schema Versioning
M anaging data structure changes over time through schema
versioning ensures backwards compatibility.

3 Data Transformation
Techniques like data transformation help handle deprecated
fields and migrate data to new structures.
Use Cases: Where Schema Flexibility Shines
Catalog Management Content Management
Product catalogs with varying attributes (size, color, material) can Diverse content types with custom fields are ideal for schema
be managed easily with flexible schemas. flexibility, allowing for dynamic and adaptable content structures.

IoT Data User Profiles

Heterogeneous sensors with varying data formats are well-suited Storing user data with diverse attributes and preferences is easily
for schema flexibility, enabling efficient data collection and analysis. managed with flexible schemas, accommodating individual
differences.
Implementing Schema Flexibility:
Best Practices
Data Modeling
A thorough understanding of the application's data requirements is crucial for
designing effective flexible schemas.

Optional Fields
Using optional fields allows for flexibility in data structure, accommodating
variations in data without requiring separate collections.

Default Values
Default values provide a way to manage missing data, ensuring consistency and
preventing errors during processing.

Schema Evolution
Handle schema evolution gracefully, ensuring backwards compatibility and
smooth transitions between different data models.
Conclusion: Embracing
Schema Flexibility for Modern
Applications
Schema flexibility in document databases offers a powerful solution for
building agile, adaptable, and scalable applications. By embracing these
principles, developers can create modern systems that can evolve with
changing business needs and deliver optimal performance.
• JSON stands for JavaScript Object Notation. It's a lightweight, human-readable format for data
interchange. Think of it as a way to easily transmit data between a server and a web application (or
any other application) in a format that's both easy for humans to understand and easy for machines
to parse and generate.
• Here's a breakdown of what makes JSON useful:
• Lightweight: Compared to other data formats like XML, JSON has less overhead (fewer
characters, less complexity). This makes it faster to transmit and parse.
• Human-Readable: JSON is based on a simple text format that's relatively easy to read and
understand. It looks a lot like JavaScript objects.
• Easy to Parse: Most programming languages have built-in libraries or functions to easily parse
(read) and generate JSON data.
• Language Independent: While it originated with JavaScript, JSON is a language-independent
format. It's used with virtually every programming language.

•Objects: Collections of key-value pairs, enclosed in curly braces . Keys are strings, and values can be any valid JSON data type.
•Arrays: Ordered lists of values, enclosed in square brackets [].
•Strings: Textual data, enclosed in double quotes "".
•Numbers: Integers or flating-point numbers.
•Booleans: true or false.
•Null: Represents the absence of a value.
JSON supports the following basic data structures:

•Objects: Collections of key-value pairs, enclosed in curly braces . Keys are strings, and values can be any valid JSON data type.
•Arrays: Ordered lists of values, enclosed in square brackets [].
•Strings: Textual data, enclosed in double quotes "".
•Numbers: Integers or flating-point numbers.
•Booleans: true or false.
•Null: Represents the absence of a value.
Many to Many Relation in Document Database
In the relational algebra, you would instead write:
sharks = σfamily = “Sharks” (animals)
Introduction to MapReduce
Data Modeling
MapReduce is a programming model and a software framework designed for
processing massive datasets across distributed systems. The core of
MapReduce lies in its ability to handle massive data by splitting it into
smaller chunks, processing those chunks in parallel, and finally combining
the results for an overall solution.
MapReduce Architecture and Workflow
Map Phase Shuffle & Sort Phase Reduce Phase

The Map phase processes the input The Shuffle phase gathers the output The Reduce phase processes the sorted
data in parallel, transforming it into key- key-value pairs from the Map phase and key-value pairs, combining values with
value pairs. These pairs are then sent to groups them by key. The data is sorted the same key to generate final results.
the Shuffle phase for sorting and based on the keys, preparing it for the The output from the Reduce phase can
aggregation. Reduce phase. then be stored or further processed.
Advantages of MapReduce

1 Scalability 2 Fault Tolerance 3 Parallel Processing

MapReduce can handle massive MapReduce is designed to be MapReduce utilizes parallel
datasets by distributing the robust and fault-tolerant, processing to speed up data
processing workload across automatically recovering from analysis by processing multiple
multiple machines. node failures. tasks simultaneously.

4 Cost-Effectiveness 5 Flexibility
MapReduce leverages commodity hardware, making it an MapReduce supports various data formats and
efficient solution for large-scale data processing. programming languages, enabling flexibility in data
analysis.
Disadvantages and Limitations of MapReduce
Complexity Latency
Developing and debugging MapReduce jobs can be complex, MapReduce's batch processing nature can introduce delays, making
requiring expertise in distributed computing. it unsuitable for real-time data analysis.

Suitability Alternatives
MapReduce is not ideal for real-time or interactive queries that Newer data processing frameworks, such as Spark, Flink, and
require low latency responses. others, offer faster processing speeds and greater flexibility.
Use Case 1: Log Analysis

Analyzing web server By processing For example, we can

logs can reveal terabytes of log data, analyze Apache web
valuable insights into we can generate server logs to identify
user behavior and summary reports on the top 10 most visited
website performance. popular pages, error pages, providing
patterns, and more. valuable information
for website
optimization.
Use Case 2: Indexing Web Content
Keyword Extraction
Relevant keywords and metadata are
extracted from each web page, creating a
2
Crawling semantic representation of the content.

Web pages are crawled and collected,

1
gathering information from across the Inverted Index
internet.
An inverted index is built, mapping
3 keywords to the web pages where they
appear, enabling fast and efficient search
queries.
Conclusion: The Enduring
Relevance of MapReduce
1 Historical Relevance
MapReduce paved the way for modern distributed data processing
frameworks, laying the foundation for today's big data solutions.

2 Current Landscape
MapReduce remains a valuable tool for many use cases, particularly
those involving large datasets with batch processing requirements.

3 Future Trends
MapReduce continues to evolve, with new advancements in fault
tolerance, scalability, and performance optimizations.
Introduction to Graph-Like
Data Models
Key Concepts: Nodes, Relationships, Properties
Nodes Relationships Properties

Nodes represent entities, like people, Relationships define connections Properties are attributes of nodes and
places, or things. They are the between nodes. They describe how relationships. They provide additional
fundamental building blocks of a graph. entities interact, such as "friend," information, like "name," "age," or
"knows," or "lives_in." "weight."
Common Graph Data Models
Property Graphs
Nodes and relationships have properties. Popular examples include Neo4j and
JanusGraph.

RDF Triples
Represent data as Subject-Predicate-Object triples. Wikidata and Amazon Neptune are
notable examples.

Labeled Property Graphs

Combine features of property graphs and RDF triples. They offer flexibility and
expressiveness.

Hypergraphs
Allow relationships to connect more than two nodes, enabling modeling of complex
interactions.
Use Cases: Social Networks and Recommendations

Social Networks Recommendations

Model user connections, identify influencers, and detect Discover related products, personalize suggestions, and

communities within networks. implement collaborative filtering.

Graph Query Languages
1 Cypher is a declarative query 2 SPARQL is a standardized
language for property query language for RDF
graphs. triples.

3 Gremlin is a graph traversal language, enabling complex pattern

matching.
Advantages and Disadvantages
Model Advantages Disadvantages

Graph Efficient relationship Scalability challenges,

traversal, support for query optimization
complex queries, intuitive complexity, steeper
modeling. learning curve.

Relational Data integrity, ACID Inefficient for complex

properties, well- relationships, joins can be
established tools. slow, normalization
challenges.

Document Flexible schema, ease of Limited query capabilities,

use, good for data consistency
unstructured data. challenges, difficult for
complex relationships.
Conclusion: The Future of
Graph Data
Graph databases are essential for data-intensive applications, offering
significant advantages in modeling complex relationships and performing
advanced queries. Their growing importance in modern technology
underscores the need to explore their capabilities for future projects.
 Cypher
Cypher is a declarative query language used to query and manipulate graph
databases, particularly Neo4j, which is one of the most popular graph database
management systems. Cypher is designed to be human-readable and intuitive,
making it easier to work with graph data structures
Key Concepts in Cypher
Cypher Query Language for Graph Databases
Advanced Cypher Features
Example Use Case: Social Network
Another Example
 Resource Description Framework
The RDF (Resource Description Framework) data model is a framework used to describe
relationships between resources (objects or entities) on the web, primarily focusing on the
structure and meaning of data. It's the foundation of many semantic web technologies. RDF uses a
graph-based structure that represents data in triples, consisting of:
• Subject: The resource or entity being described (e.g., a person, a book, a company).
• Predicate: The property or relationship of the subject (e.g., "hasAuthor," "isLocatedIn").
• Object: The value or target resource of the predicate (e.g., the author's name, the city).
 RDF Triple Example:
A triple in RDF could look like this:
• Subject: "John"
• Predicate: "hasAge"
• Object: "30
 Graph Representation
RDF data can be visualized as a directed graph where:
• Nodes represent subjects and objects.
• Arcs (edges) represent predicates (properties or relationships).
For example, the RDF triple:
• Subject: "John"
• Predicate: "hasAge"
• Object: "30“
can be represented as a directed edge from the node "John" to the node "30"
labeled with "hasAge."
 Key Concepts in RDF

• URI (Uniform Resource Identifier): A unique identifier used for resources. It’s
how RDF uniquely identifies subjects, predicates, and objects.
• Blank Nodes: These are used when a resource does not have a specific URI. They
are useful for anonymous resources in RDF.
• Literals: Plain data values, such as numbers, strings, dates, etc., that are used as
objects in RDF.
 RDF Syntaxes
• RDF can be expressed in different syntaxes, such as:
• RDF/XML: A verbose XML-based syntax.
• Turtle: A more compact and human-readable syntax.
• JSON-LD: A JSON-based format for RDF, often used in web applications.
 Use Cases of RDF
• Semantic Web: RDF is a cornerstone for creating linked data on the web, enabling
machines to understand and use the relationships between data.
• Metadata Description: RDF is used to describe metadata in various domains, like
bibliographic data, geographic data, and more.
• Knowledge Graphs: RDF forms the backbone of many knowledge graphs,
including Google’s Knowledge Graph.
 Example 1: Describing a Person
• Let’s say we want to describe a person named John who is 30 years old and works as a software
engineer.
RDF Triples:
• (John, hasAge, 30)
• Subject: John
• Predicate: hasAge
• Object: 30
• (John, hasOccupation, Software Engineer)
• Subject: John
• Predicate: hasOccupation
• Object: Software Engineer

<[Link] <[Link] "30" .

<[Link] <[Link] "Software Engineer" .
 Example 2: Describing a Book
Now, let's describe a book called "Learning RDF" by Jane Doe.
RDF Triples:
• (Learning RDF, hasAuthor, Jane Doe)
• Subject: Learning RDF (the book)
• Predicate: hasAuthor
• Object: Jane Doe
• (Learning RDF, hasPublicationYear, 2022)
• Subject: Learning RDF
• Predicate: hasPublicationYear
• Object: 2022

<[Link] <[Link] "Jane Doe" .

<[Link] <[Link] "2022" .
 Visualizing RDF Triples as a Graph
• Let’s visualize one of the examples:
• For the triples about John:
• (John, hasAge, 30)
• (John, hasOccupation, Software Engineer)
It could be represented as a directed graph:
example
 SPARQL
• SPARQL (pronounced "sparkle") is a query language and protocol
used for querying and manipulating data stored in RDF (Resource
Description Framework) format.
 Key Features of SPARQL:
• Querying RDF Data:
• SPARQL allows you to query RDF graphs to extract specific information. It can retrieve data
based on patterns in the RDF graph, such as triples (subject-predicate-object).
• Pattern Matching:
• SPARQL queries are based on graph pattern matching. You specify patterns of triples, and the
query engine returns data that matches those patterns.
• Flexible Querying:
• SPARQL supports a wide range of query types, including:
• SELECT: Retrieves specific variables from the RDF graph.
• CONSTRUCT: Constructs a new RDF graph based on the query results.
• ASK: Returns a boolean (true/false) indicating whether a pattern exists in the data.
• DESCRIBE: Returns an RDF graph that describes the resources matching the query
• Filtering and Sorting: SPARQL supports filtering results using conditions (e.g., FILTER) and
sorting results using ORDER BY.
• Aggregation: SPARQL supports aggregation functions like COUNT, SUM, AVG, MIN,
and MAX for summarizing data
• Federated Queries: SPARQL can query multiple RDF datasets across different endpoints using
the SERVICE keyword.
SPARQL VS CYPHER
Legacy Data Models
 Hierarchical data model
• The hierarchical data model is one of the earliest database models, designed to represent data in a
tree-like structure. It organizes data in a parent-child relationship, where each parent record can
have multiple child records, but each child record has only one parent. This model was widely used
in early database management systems (DBMS) like IBM's Information Management System
(IMS)
 Network data model
• The network data model is a type of database model that represents data as a collection of records
and relationships between these records. It is an extension of the hierarchical data model but allows
for more complex relationships, such as many-to-many relationships. In the network data model,
data is organized in a graph-like structure where records (nodes) are connected via links (edges).
 Example of Network Data Model
Consider a university database with the following entities:
• Student: (Student_ID, Name, Address)
• Course: (Course_ID, Course_Name, Credits)
• Enrollment: Represents the relationship between students and courses.
Real World Example