Chad Tindel's presentation covered schema design considerations for MongoDB including working with documents, evolving schemas over time, queries and indexes, and common data modeling patterns. Some key points included embedding data for performance, using references when growth is unbounded, and modeling one-to-many relationships by either embedding the related data or storing foreign keys. The presentation provided examples of modeling patrons, books, publishers, and other data to demonstrate schema patterns for trees, inheritance, and other common relationships.
One of the challenges that comes with moving to MongoDB is figuring how to best model your data. While most developers have internalized the rules of thumb for designing schemas for RDBMSs, these rules don't always apply to MongoDB. The simple fact that documents can represent rich, schema-free data structures means that we have a lot of viable alternatives to the standard, normalized, relational model. Not only that, MongoDB has several unique features, such as atomic updates and indexed array keys, that greatly influence the kinds of schemas that make sense. Understandably, this begets good questions: Are foreign keys permissible, or is it better to represent one-to-many relations withing a single document? Are join tables necessary, or is there another technique for building out many-to-many relationships? What level of denormalization is appropriate? How do my data modeling decisions affect the efficiency of updates and queries? In this session, we'll answer these questions and more, provide a number of data modeling rules of thumb, and discuss the tradeoffs of various data modeling strategies.
The document discusses various schema design considerations for MongoDB including modeling one-to-one, one-to-many, and many-to-many relationships. It provides examples of embedding documents versus referencing them with foreign keys. Other topics covered include evolving schemas, indexing, common data patterns such as trees, and handling queues.
MongoDB’s basic unit of storage is a document. Documents can represent rich, schema-free data structures, meaning that we have several viable alternatives to the normalized, relational model. In this talk, we’ll discuss the tradeoff of various data modeling strategies in MongoDB using a library as a sample application. You will learn how to work with documents, evolve your schema, and common schema design patterns.
The document provides an overview of schema design considerations for MongoDB databases. It discusses modeling different types of relationships like one-to-one, one-to-many, and many-to-many. Examples are given for embedding vs referencing related data as well as techniques for trees, single table inheritance, and queues. Key points covered include evolving schemas based on data usage patterns, embedding for performance vs referencing for flexibility, and modeling relationships in MongoDB similarly to relational databases while leveraging embedding and references.
This document provides an overview of schema design considerations when using MongoDB. It discusses modeling one-to-one, one-to-many, and many-to-many relationships using embedding and references. It also covers topics like embedding for performance, updating embedded documents atomically, and modeling trees and queues.
The document discusses schema design considerations for MongoDB, including modeling one-to-one, one-to-many, and many-to-many relationships through embedding documents and references. It provides examples of embedding data to represent trees, queues, and single table inheritance. The key points are that document databases like MongoDB focus on data use rather than storage, and embedding provides data locality while references provide more flexibility.
This document discusses schema design in MongoDB. It provides examples of embedding documents versus linking between collections to model one-to-one and one-to-many relationships. Common patterns like modeling trees with parent links or arrays of ancestors are demonstrated. The document also discusses single table inheritance in MongoDB by storing different types of documents in a single collection.
The document summarizes a MongoDB presentation on schema design. It discusses modeling data through embedding and references, including examples of one-to-one, one-to-many, and many-to-many relationships. It also covers topics like indexing, data manipulation, and common modeling patterns like trees and queues.
One of the challenges that comes with moving to MongoDB is figuring how to best model your data. While most developers have internalized the rules of thumb for designing schemas for RDBMSs, these rules don't always apply to MongoDB. The simple fact that documents can represent rich, schema-free data structures means that we have a lot of viable alternatives to the standard, normalized, relational model. Not only that, MongoDB has several unique features, such as atomic updates and indexed array keys, that greatly influence the kinds of schemas that make sense. Understandably, this begets good questions: Are foreign keys permissible, or is it better to represent one-to-many relations withing a single document? Are join tables necessary, or is there another technique for building out many-to-many relationships? What level of denormalization is appropriate? How do my data modeling decisions affect the efficiency of updates and queries? In this session, we'll answer these questions and more, provide a number of data modeling rules of thumb, and discuss the tradeoffs of various data modeling strategies.
The document discusses various schema design considerations for MongoDB including modeling one-to-one, one-to-many, and many-to-many relationships. It provides examples of embedding documents versus referencing them with foreign keys. Other topics covered include evolving schemas, indexing, common data patterns such as trees, and handling queues.
MongoDB’s basic unit of storage is a document. Documents can represent rich, schema-free data structures, meaning that we have several viable alternatives to the normalized, relational model. In this talk, we’ll discuss the tradeoff of various data modeling strategies in MongoDB using a library as a sample application. You will learn how to work with documents, evolve your schema, and common schema design patterns.
The document provides an overview of schema design considerations for MongoDB databases. It discusses modeling different types of relationships like one-to-one, one-to-many, and many-to-many. Examples are given for embedding vs referencing related data as well as techniques for trees, single table inheritance, and queues. Key points covered include evolving schemas based on data usage patterns, embedding for performance vs referencing for flexibility, and modeling relationships in MongoDB similarly to relational databases while leveraging embedding and references.
This document provides an overview of schema design considerations when using MongoDB. It discusses modeling one-to-one, one-to-many, and many-to-many relationships using embedding and references. It also covers topics like embedding for performance, updating embedded documents atomically, and modeling trees and queues.
The document discusses schema design considerations for MongoDB, including modeling one-to-one, one-to-many, and many-to-many relationships through embedding documents and references. It provides examples of embedding data to represent trees, queues, and single table inheritance. The key points are that document databases like MongoDB focus on data use rather than storage, and embedding provides data locality while references provide more flexibility.
This document discusses schema design in MongoDB. It provides examples of embedding documents versus linking between collections to model one-to-one and one-to-many relationships. Common patterns like modeling trees with parent links or arrays of ancestors are demonstrated. The document also discusses single table inheritance in MongoDB by storing different types of documents in a single collection.
The document summarizes a MongoDB presentation on schema design. It discusses modeling data through embedding and references, including examples of one-to-one, one-to-many, and many-to-many relationships. It also covers topics like indexing, data manipulation, and common modeling patterns like trees and queues.
This document summarizes a presentation on schema design in MongoDB. Some key points covered include:
- MongoDB uses collections instead of tables and documents instead of rows.
- Schema design focuses on how an application will access and use data, rather than on data storage.
- Embedded documents are useful for one-to-one relationships but can impact write performance.
- Linked data using references is more flexible and ensures data integrity.
- Examples demonstrate different approaches to modeling one-to-one, one-to-many relationships and categories.
Robert Stam discusses schema design in MongoDB. Some key points:
- MongoDB uses collections instead of tables and documents instead of rows.
- Schema design focuses on how an application will access and use data, rather than on data storage.
- Relationships can be modeled through embedding documents, linking documents through IDs, or embedding IDs in other documents. The best approach depends on read/write patterns.
- Examples show modeling one-to-one, one-to-many, and many-to-many relationships through embedding, linking, and linking in both directions between collections.
- Categories can be modeled as documents, arrays, or hierarchical paths.
This document summarizes a presentation on schema design in MongoDB. It discusses modeling different types of relationships between documents, including one-to-one, one-to-many, and many-to-many. It provides examples of embedding documents versus referencing them by ID. It also covers considerations for data access patterns and data growth.
Mike Friedman discusses schema design considerations for MongoDB. He covers common data modeling patterns like one-to-one, one-to-many, and many-to-many relationships. Embedded documents are recommended when related data is often accessed together, while references are better when flexibility is needed. Trees can be modeled with either parent or child links. The document model focuses on data access rather than storage.
This document discusses schema design patterns for MongoDB. It begins by comparing terminology between relational databases and MongoDB. Common patterns for modeling one-to-one, one-to-many, and many-to-many relationships are presented using examples of patrons, books, authors, and publishers. Embedded documents are recommended when related data always appears together, while references are used when more flexibility is needed. The document emphasizes focusing on how the application accesses and manipulates data when deciding between embedded documents and references. It also stresses evolving schemas to meet changing requirements and application logic.
The document discusses schema design principles for MongoDB. It explains that schema design focuses on how an application will access and use data, rather than how data will be stored. Embedded documents are used for one-to-one relationships to optimize read performance, while linking is better for one-to-many relationships to maintain data integrity. The document provides examples of embedding, linking, and different ways of modeling categories to show how schema design choices depend on the types of queries an application needs to support.
This document discusses document databases and schema design when modeling data. It introduces key concepts like embedding related data within documents for optimal performance and flexibility compared to traditional relational schemas. Examples are provided for how to model one-to-one, one-to-many, and many-to-many relationships either through embedding or referencing other documents. General recommendations suggest embedding by default for relationships where related data is often accessed together, while referencing may be better for scaling or inconsistent many-to-many relationships. The goal is to design schemas that match how the application will use the data for best results.
The document provides an agenda and overview for a presentation on schema design in MongoDB. Some key points include:
- Discussing common patterns for modeling one-to-one, one-to-many, and many-to-many relationships
- Examples of embedding vs. linking related data
- Considerations for schema design like data access patterns and growth
- Modeling trees and hierarchies using parent/child references
The presentation covers modeling different types of relationships and navigating tradeoffs in schema design.
This document discusses schema design approaches for MongoDB databases. It provides examples of embedding vs linking related data like addresses and authors. Embedding optimizes for read performance but can make writes slower and require managing data integrity. Linking is more flexible and builds in data integrity but requires joins during reads. The document also covers modeling many-to-many relationships like categories and discusses options for storing hierarchical category data. The key lessons are that MongoDB schema design focuses on data usage instead of storage and schemas can evolve over time as requirements change.
MongoDB San Francisco 2013: Schema design presented by Jason Zucchetto, Consu...MongoDB
MongoDB’s basic unit of storage is a document. Documents can represent rich, schema-free data structures, meaning that we have several viable alternatives to the normalized, relational model. In this talk, we’ll discuss the tradeoff of various data modeling strategies in MongoDB using a library as a sample application. You will learn how to work with documents, evolve your schema, and common schema design patterns.
NoSQL databases only unfold their entire strength when also embracing the their concepts regarding usage and schema design. These slides give some overview of features and concepts of MongoDB.
MongoDB Schema Design: Four Real-World ExamplesMike Friedman
This document discusses different schema designs for common use cases in MongoDB. It presents four cases: (1) modeling a message inbox, (2) retaining historical data within limits, (3) storing variable attributes efficiently, and (4) looking up users by multiple identities. For each case, it analyzes different modeling approaches, considering factors like query performance, write performance, and whether indexes can be used. The goal is to help designers choose an optimal schema based on their application's access patterns and scale requirements.
MongoDB Schema Design (Event: An Evening with MongoDB Houston 3/11/15)MongoDB
The document discusses different data modeling approaches for structuring data in MongoDB, including embedding data versus referencing data in collections. It provides examples of modeling one-to-one, one-to-many, and many-to-many relationships between entities using embedding and referencing. The document recommends different approaches depending on the use case and prioritizes flexibility, performance, and optimal data representation.
Dev Jumpstart: Schema Design Best PracticesMongoDB
New to MongoDB? We’ll discuss the tradeoff of various data modeling strategies in MongoDB. This talk will jumpstart your knowledge of how to work with documents, evolve your schema, and common schema design patterns. MongoDB’s basic unit of storage is a document. No prior knowledge of MongoDB is assumed.
This document provides an introduction to MongoDB and building a sample library management application using MongoDB. It discusses key MongoDB concepts like using documents and collections instead of tables and rows, embedding documents, indexing, and querying. Examples are given of inserting, updating, and querying book and author documents to model the library application. The document emphasizes that MongoDB allows flexible schema evolution and complex queries on nested and array data.
MongoDB’s basic unit of storage is a document. Documents can represent rich, schema-free data structures, meaning that we have several viable alternatives to the normalized, relational model. In this talk, we’ll discuss the tradeoff of various data modeling strategies in MongoDB.
Schema Design by Example ~ MongoSF 2012hungarianhc
This document summarizes a presentation about schema design in MongoDB. It discusses embedding documents, linking documents through references, and using geospatial data for check-ins. Examples are given for modeling blog posts and comments, places with metadata, and user profiles with check-in histories. The document emphasizes designing schemas based on application needs rather than relational normalization.
This document provides an overview of schema design considerations for MongoDB. It discusses modeling different types of relationships like one-to-one, one-to-many, and many-to-many. It also covers topics like embedding vs referencing, indexing, and common patterns like trees and queues. The key message is that schema design should focus on how the data will be used by applications rather than how it is stored, as the document model provides more flexibility compared to relational databases.
Building web applications with mongo db presentationMurat Çakal
The document introduces building web applications using MongoDB, a document-oriented database. It discusses MongoDB's data modeling and querying capabilities, including examples of modeling user and location data for a check-in application. The document also covers indexing, insertion, updating, and analytics queries for the sample location and user data models.
The document discusses schema design in MongoDB. It explains that MongoDB uses documents rather than tables and rows. Documents can be normalized, with links between separate documents, or denormalized by embedding related data. Embedding is recommended for fast queries but normalized schemas also work well. The document also covers indexing strategies, profiling database performance, and provides examples of schema designs for events, seating, and a feed reader application.
This document summarizes a presentation on schema design in MongoDB. Some key points covered include:
- MongoDB uses collections instead of tables and documents instead of rows.
- Schema design focuses on how an application will access and use data, rather than on data storage.
- Embedded documents are useful for one-to-one relationships but can impact write performance.
- Linked data using references is more flexible and ensures data integrity.
- Examples demonstrate different approaches to modeling one-to-one, one-to-many relationships and categories.
Webinar: Back to Basics: Thinking in DocumentsMongoDB
New applications, users and inputs demand new types of data, like unstructured, semi-structured and polymorphic data. Adopting MongoDB means adopting to a new, document-based data model.
While most developers have internalized the rules of thumb for designing schemas for relational databases, these rules don't apply to MongoDB. Documents can represent rich data structures, providing lots of viable alternatives to the standard, normalized, relational model. In addition, MongoDB has several unique features, such as atomic updates and indexed array keys, that greatly influence the kinds of schemas that make sense.
In this session, Buzz Moschetti explores how you can take advantage of MongoDB's document model to build modern applications.
This document summarizes a presentation on schema design in MongoDB. Some key points covered include:
- MongoDB uses collections instead of tables and documents instead of rows.
- Schema design focuses on how an application will access and use data, rather than on data storage.
- Embedded documents are useful for one-to-one relationships but can impact write performance.
- Linked data using references is more flexible and ensures data integrity.
- Examples demonstrate different approaches to modeling one-to-one, one-to-many relationships and categories.
Robert Stam discusses schema design in MongoDB. Some key points:
- MongoDB uses collections instead of tables and documents instead of rows.
- Schema design focuses on how an application will access and use data, rather than on data storage.
- Relationships can be modeled through embedding documents, linking documents through IDs, or embedding IDs in other documents. The best approach depends on read/write patterns.
- Examples show modeling one-to-one, one-to-many, and many-to-many relationships through embedding, linking, and linking in both directions between collections.
- Categories can be modeled as documents, arrays, or hierarchical paths.
This document summarizes a presentation on schema design in MongoDB. It discusses modeling different types of relationships between documents, including one-to-one, one-to-many, and many-to-many. It provides examples of embedding documents versus referencing them by ID. It also covers considerations for data access patterns and data growth.
Mike Friedman discusses schema design considerations for MongoDB. He covers common data modeling patterns like one-to-one, one-to-many, and many-to-many relationships. Embedded documents are recommended when related data is often accessed together, while references are better when flexibility is needed. Trees can be modeled with either parent or child links. The document model focuses on data access rather than storage.
This document discusses schema design patterns for MongoDB. It begins by comparing terminology between relational databases and MongoDB. Common patterns for modeling one-to-one, one-to-many, and many-to-many relationships are presented using examples of patrons, books, authors, and publishers. Embedded documents are recommended when related data always appears together, while references are used when more flexibility is needed. The document emphasizes focusing on how the application accesses and manipulates data when deciding between embedded documents and references. It also stresses evolving schemas to meet changing requirements and application logic.
The document discusses schema design principles for MongoDB. It explains that schema design focuses on how an application will access and use data, rather than how data will be stored. Embedded documents are used for one-to-one relationships to optimize read performance, while linking is better for one-to-many relationships to maintain data integrity. The document provides examples of embedding, linking, and different ways of modeling categories to show how schema design choices depend on the types of queries an application needs to support.
This document discusses document databases and schema design when modeling data. It introduces key concepts like embedding related data within documents for optimal performance and flexibility compared to traditional relational schemas. Examples are provided for how to model one-to-one, one-to-many, and many-to-many relationships either through embedding or referencing other documents. General recommendations suggest embedding by default for relationships where related data is often accessed together, while referencing may be better for scaling or inconsistent many-to-many relationships. The goal is to design schemas that match how the application will use the data for best results.
The document provides an agenda and overview for a presentation on schema design in MongoDB. Some key points include:
- Discussing common patterns for modeling one-to-one, one-to-many, and many-to-many relationships
- Examples of embedding vs. linking related data
- Considerations for schema design like data access patterns and growth
- Modeling trees and hierarchies using parent/child references
The presentation covers modeling different types of relationships and navigating tradeoffs in schema design.
This document discusses schema design approaches for MongoDB databases. It provides examples of embedding vs linking related data like addresses and authors. Embedding optimizes for read performance but can make writes slower and require managing data integrity. Linking is more flexible and builds in data integrity but requires joins during reads. The document also covers modeling many-to-many relationships like categories and discusses options for storing hierarchical category data. The key lessons are that MongoDB schema design focuses on data usage instead of storage and schemas can evolve over time as requirements change.
MongoDB San Francisco 2013: Schema design presented by Jason Zucchetto, Consu...MongoDB
MongoDB’s basic unit of storage is a document. Documents can represent rich, schema-free data structures, meaning that we have several viable alternatives to the normalized, relational model. In this talk, we’ll discuss the tradeoff of various data modeling strategies in MongoDB using a library as a sample application. You will learn how to work with documents, evolve your schema, and common schema design patterns.
NoSQL databases only unfold their entire strength when also embracing the their concepts regarding usage and schema design. These slides give some overview of features and concepts of MongoDB.
MongoDB Schema Design: Four Real-World ExamplesMike Friedman
This document discusses different schema designs for common use cases in MongoDB. It presents four cases: (1) modeling a message inbox, (2) retaining historical data within limits, (3) storing variable attributes efficiently, and (4) looking up users by multiple identities. For each case, it analyzes different modeling approaches, considering factors like query performance, write performance, and whether indexes can be used. The goal is to help designers choose an optimal schema based on their application's access patterns and scale requirements.
MongoDB Schema Design (Event: An Evening with MongoDB Houston 3/11/15)MongoDB
The document discusses different data modeling approaches for structuring data in MongoDB, including embedding data versus referencing data in collections. It provides examples of modeling one-to-one, one-to-many, and many-to-many relationships between entities using embedding and referencing. The document recommends different approaches depending on the use case and prioritizes flexibility, performance, and optimal data representation.
Dev Jumpstart: Schema Design Best PracticesMongoDB
New to MongoDB? We’ll discuss the tradeoff of various data modeling strategies in MongoDB. This talk will jumpstart your knowledge of how to work with documents, evolve your schema, and common schema design patterns. MongoDB’s basic unit of storage is a document. No prior knowledge of MongoDB is assumed.
This document provides an introduction to MongoDB and building a sample library management application using MongoDB. It discusses key MongoDB concepts like using documents and collections instead of tables and rows, embedding documents, indexing, and querying. Examples are given of inserting, updating, and querying book and author documents to model the library application. The document emphasizes that MongoDB allows flexible schema evolution and complex queries on nested and array data.
MongoDB’s basic unit of storage is a document. Documents can represent rich, schema-free data structures, meaning that we have several viable alternatives to the normalized, relational model. In this talk, we’ll discuss the tradeoff of various data modeling strategies in MongoDB.
Schema Design by Example ~ MongoSF 2012hungarianhc
This document summarizes a presentation about schema design in MongoDB. It discusses embedding documents, linking documents through references, and using geospatial data for check-ins. Examples are given for modeling blog posts and comments, places with metadata, and user profiles with check-in histories. The document emphasizes designing schemas based on application needs rather than relational normalization.
This document provides an overview of schema design considerations for MongoDB. It discusses modeling different types of relationships like one-to-one, one-to-many, and many-to-many. It also covers topics like embedding vs referencing, indexing, and common patterns like trees and queues. The key message is that schema design should focus on how the data will be used by applications rather than how it is stored, as the document model provides more flexibility compared to relational databases.
Building web applications with mongo db presentationMurat Çakal
The document introduces building web applications using MongoDB, a document-oriented database. It discusses MongoDB's data modeling and querying capabilities, including examples of modeling user and location data for a check-in application. The document also covers indexing, insertion, updating, and analytics queries for the sample location and user data models.
The document discusses schema design in MongoDB. It explains that MongoDB uses documents rather than tables and rows. Documents can be normalized, with links between separate documents, or denormalized by embedding related data. Embedding is recommended for fast queries but normalized schemas also work well. The document also covers indexing strategies, profiling database performance, and provides examples of schema designs for events, seating, and a feed reader application.
This document summarizes a presentation on schema design in MongoDB. Some key points covered include:
- MongoDB uses collections instead of tables and documents instead of rows.
- Schema design focuses on how an application will access and use data, rather than on data storage.
- Embedded documents are useful for one-to-one relationships but can impact write performance.
- Linked data using references is more flexible and ensures data integrity.
- Examples demonstrate different approaches to modeling one-to-one, one-to-many relationships and categories.
Webinar: Back to Basics: Thinking in DocumentsMongoDB
New applications, users and inputs demand new types of data, like unstructured, semi-structured and polymorphic data. Adopting MongoDB means adopting to a new, document-based data model.
While most developers have internalized the rules of thumb for designing schemas for relational databases, these rules don't apply to MongoDB. Documents can represent rich data structures, providing lots of viable alternatives to the standard, normalized, relational model. In addition, MongoDB has several unique features, such as atomic updates and indexed array keys, that greatly influence the kinds of schemas that make sense.
In this session, Buzz Moschetti explores how you can take advantage of MongoDB's document model to build modern applications.
Modeling JSON data for NoSQL document databasesRyan CrawCour
Modeling data in a relational database is easy, we all know how to do it because that's what we've always been taught; But what about NoSQL Document Databases?
Document databases take (much) of what you know and flip it upside down. This talk covers some common patterns for modeling data and how to approach things when working with document stores such as Azure DocumentDB
This document discusses schema design in MongoDB. It covers topics like working with documents, evolving schemas, queries and indexes. It provides examples of modeling common patterns like inheritance, one-to-many and many-to-many relationships, and trees. It discusses embedding data versus referencing it in different collections and considerations for schema design like access patterns and data size.
Webinar: General Technical Overview of MongoDB for Dev TeamsMongoDB
In this talk we will focus on several of the reasons why developers have come to love the richness, flexibility, and ease of use that MongoDB provides. First we will give a brief introduction of MongoDB, comparing and contrasting it to the traditional relational database. Next, we’ll give an overview of the APIs and tools that are part of the MongoDB ecosystem. Then we’ll look at how MongoDB CRUD (Create, Read, Update, Delete) operations work, and also explore query, update, and projection operators. Finally, we will discuss MongoDB indexes and look at some examples of how indexes are used.
Conceptos básicos. seminario web 3 : Diseño de esquema pensado para documentosMongoDB
Este es el tercer seminario web de la serie Conceptos básicos, en la que se realiza una introducción a la base de datos MongoDB. En este seminario web se explica la arquitectura de las bases de datos de documentos.
Media owners are turning to MongoDB to drive social interaction with their published content. The way customers consume information has changed and passive communication is no longer enough. They want to comment, share and engage with publishers and their community through a range of media types and via multiple channels whenever and wherever they are. There are serious challenges with taking this semi-structured and unstructured data and making it work in a traditional relational database. This webinar looks at how MongoDB’s schemaless design and document orientation gives organisation’s like the Guardian the flexibility to aggregate social content and scale out.
10gen Presents Schema Design and Data ModelingDATAVERSITY
This document provides an overview of schema design in MongoDB. It discusses topics such as:
- The goals of schema design, which include avoiding anomalies, minimizing redesign, avoiding query bias, and making use of features.
- Key terminology when comparing MongoDB to relational databases, such as using collections instead of tables and embedding/linking instead of joins.
- Examples of basic collections, documents, indexing, and query operators.
- Common schema patterns for MongoDB like embedding, normalization, inheritance, one-to-many, many-to-many, and trees.
- Use cases like time series are also briefly covered.
This talk will introduce the philosophy and features of the open source, NoSQL MongoDB. We’ll discuss the benefits of the document-based data model that MongoDB offers by walking through how one can build a simple app to store books. We’ll cover inserting, updating, and querying the database of books.
Christian Kvalheim gave an introduction to NoSQL and MongoDB. Some key points:
1) MongoDB is a scalable, high-performance, open source NoSQL database that uses a document-oriented model.
2) It supports indexing, replication, auto-sharding for horizontal scaling, and querying.
3) Documents are stored in JSON-like records which can contain various data types including nested objects and arrays.
MongoDB is a document-oriented, horizontally scalable database. It uses dynamic schemas and stores data as JSON-like documents with optional schemas. MongoDB can be scaled out across multiple servers for high availability and large data volumes. Key features include replication, sharding, index types, atomic operations, embedded documents, and MapReduce.
This document provides an overview of MongoDB for Java developers. It discusses what MongoDB is, how it compares to relational databases, common use cases, data modeling approaches, CRUD operations, indexing, aggregation, replication, sharding, and tools for integrating MongoDB with Java applications. The document contains multiple code examples and concludes with a demonstration of building a sample app with MongoDB.
Presentation on MongoDB given at the Hadoop DC meetup in October 2009. Some of the slides at the end are extra examples that didn't appear in the talk, but might be of interest.
This document provides an overview of MongoDB, an open-source, schema-free, document-oriented database. It discusses how MongoDB offers more flexibility and scalability compared to traditional RDBMS systems. Key features covered include dynamic queries, replication, auto-sharding, and support for many platforms/languages. Examples are given for common operations like creating, querying, and updating document structures in MongoDB.
The document provides an overview of MongoDB, including its history, data model, comparisons to SQL databases, and basic usage. Some key points:
- MongoDB is an open-source, document-based database that is designed for high performance, high availability, and automatic scaling.
- It uses a document-oriented data model where data is stored in JSON-like documents within collections, rather than in tables with rows.
- Documents can contain different field types and embedded documents, providing a flexible schema compared to relational databases.
- Common operations like queries, updates, and aggregations can be performed on the database using CRUD functions in MongoDB's shell.
The document provides an overview of schema design in MongoDB. It discusses topics like basic data modeling, manipulating data, and evolving schemas over time. It also covers common data modeling patterns such as single table inheritance, one-to-many, many-to-many, and tree structures. The document compares MongoDB's flexible schema approach to relational databases and discusses concepts like normalization, collections, embedded documents, and indexing.
Inferring Versioned Schemas from NoSQL Databases and its ApplicationsDiego Sevilla Ruiz
This document proposes a process to infer schemas from NoSQL databases by analyzing object versions. It involves using map-reduce to extract raw schemas from objects and group them by entity and version. Relationships like references and aggregations are also modeled. This schema model can then be used to automatically generate applications like data validation, visualization, and migration tools. Future work includes building a toolset for NoSQL data engineering tasks and enhancing the inferred schema with additional type information.
MongoDB is an open source NoSQL database that uses JSON-like documents with dynamic schemas (BSON format) instead of using tables as in SQL. It allows for embedding related data and flexible querying of this embedded data. Some key features include using JavaScript-style documents, scaling horizontally on commodity hardware, and supporting various languages through its driver interface.
This document summarizes a presentation about MongoDB given by Sean Laurent of StudyBlue, Inc. It introduces MongoDB and its features, including its document-oriented data model, flexible schemas, querying and updating capabilities, indexing, drivers, replication and sharding for scalability. Useful MongoDB tools are also discussed like the mongo shell, mongostat, mongotop and MMS monitoring. The document concludes with MongoDB's strengths like horizontal scaling and rapidly evolving schemas, and weaknesses like not being a drop-in replacement for SQL and limitations around transactions.
MongoDB SoCal 2020: Migrate Anything* to MongoDB AtlasMongoDB
This presentation discusses migrating data from other data stores to MongoDB Atlas. It begins by explaining why MongoDB and Atlas are good choices for data management. Several preparation steps are covered, including sizing the target Atlas cluster, increasing the source oplog, and testing connectivity. Live migration, mongomirror, and dump/restore options are presented for migrating between replicasets or sharded clusters. Post-migration steps like monitoring and backups are also discussed. Finally, migrating from other data stores like AWS DocumentDB, Azure CosmosDB, DynamoDB, and relational databases are briefly covered.
MongoDB SoCal 2020: Go on a Data Safari with MongoDB Charts!MongoDB
These days, everyone is expected to be a data analyst. But with so much data available, how can you make sense of it and be sure you're making the best decisions? One great approach is to use data visualizations. In this session, we take a complex dataset and show how the breadth of capabilities in MongoDB Charts can help you turn bits and bytes into insights.
MongoDB SoCal 2020: Using MongoDB Services in Kubernetes: Any Platform, Devel...MongoDB
MongoDB Kubernetes operator and MongoDB Open Service Broker are ready for production operations. Learn about how MongoDB can be used with the most popular container orchestration platform, Kubernetes, and bring self-service, persistent storage to your containerized applications. A demo will show you how easy it is to enable MongoDB clusters as an External Service using the Open Service Broker API for MongoDB
MongoDB SoCal 2020: A Complete Methodology of Data Modeling for MongoDBMongoDB
Are you new to schema design for MongoDB, or are you looking for a more complete or agile process than what you are following currently? In this talk, we will guide you through the phases of a flexible methodology that you can apply to projects ranging from small to large with very demanding requirements.
MongoDB SoCal 2020: From Pharmacist to Analyst: Leveraging MongoDB for Real-T...MongoDB
Humana, like many companies, is tackling the challenge of creating real-time insights from data that is diverse and rapidly changing. This is our journey of how we used MongoDB to combined traditional batch approaches with streaming technologies to provide continues alerting capabilities from real-time data streams.
MongoDB SoCal 2020: Best Practices for Working with IoT and Time-series DataMongoDB
Time series data is increasingly at the heart of modern applications - think IoT, stock trading, clickstreams, social media, and more. With the move from batch to real time systems, the efficient capture and analysis of time series data can enable organizations to better detect and respond to events ahead of their competitors or to improve operational efficiency to reduce cost and risk. Working with time series data is often different from regular application data, and there are best practices you should observe.
This talk covers:
Common components of an IoT solution
The challenges involved with managing time-series data in IoT applications
Different schema designs, and how these affect memory and disk utilization – two critical factors in application performance.
How to query, analyze and present IoT time-series data using MongoDB Compass and MongoDB Charts
At the end of the session, you will have a better understanding of key best practices in managing IoT time-series data with MongoDB.
Join this talk and test session with a MongoDB Developer Advocate where you'll go over the setup, configuration, and deployment of an Atlas environment. Create a service that you can take back in a production-ready state and prepare to unleash your inner genius.
MongoDB .local San Francisco 2020: Powering the new age data demands [Infosys]MongoDB
Our clients have unique use cases and data patterns that mandate the choice of a particular strategy. To implement these strategies, it is mandatory that we unlearn a lot of relational concepts while designing and rapidly developing efficient applications on NoSQL. In this session, we will talk about some of our client use cases, the strategies we have adopted, and the features of MongoDB that assisted in implementing these strategies.
MongoDB .local San Francisco 2020: Using Client Side Encryption in MongoDB 4.2MongoDB
Encryption is not a new concept to MongoDB. Encryption may occur in-transit (with TLS) and at-rest (with the encrypted storage engine). But MongoDB 4.2 introduces support for Client Side Encryption, ensuring the most sensitive data is encrypted before ever leaving the client application. Even full access to your MongoDB servers is not enough to decrypt this data. And better yet, Client Side Encryption can be enabled at the "flick of a switch".
This session covers using Client Side Encryption in your applications. This includes the necessary setup, how to encrypt data without sacrificing queryability, and what trade-offs to expect.
MongoDB .local San Francisco 2020: Using MongoDB Services in Kubernetes: any ...MongoDB
MongoDB Kubernetes operator is ready for prime-time. Learn about how MongoDB can be used with most popular orchestration platform, Kubernetes, and bring self-service, persistent storage to your containerized applications.
MongoDB .local San Francisco 2020: Go on a Data Safari with MongoDB Charts!MongoDB
These days, everyone is expected to be a data analyst. But with so much data available, how can you make sense of it and be sure you're making the best decisions? One great approach is to use data visualizations. In this session, we take a complex dataset and show how the breadth of capabilities in MongoDB Charts can help you turn bits and bytes into insights.
MongoDB .local San Francisco 2020: From SQL to NoSQL -- Changing Your MindsetMongoDB
When you need to model data, is your first instinct to start breaking it down into rows and columns? Mine used to be too. When you want to develop apps in a modern, agile way, NoSQL databases can be the best option. Come to this talk to learn how to take advantage of all that NoSQL databases have to offer and discover the benefits of changing your mindset from the legacy, tabular way of modeling data. We’ll compare and contrast the terms and concepts in SQL databases and MongoDB, explain the benefits of using MongoDB compared to SQL databases, and walk through data modeling basics so you feel confident as you begin using MongoDB.
MongoDB .local San Francisco 2020: MongoDB Atlas JumpstartMongoDB
Join this talk and test session with a MongoDB Developer Advocate where you'll go over the setup, configuration, and deployment of an Atlas environment. Create a service that you can take back in a production-ready state and prepare to unleash your inner genius.
MongoDB .local San Francisco 2020: Tips and Tricks++ for Querying and Indexin...MongoDB
The document discusses guidelines for ordering fields in compound indexes to optimize query performance. It recommends the E-S-R approach: placing equality fields first, followed by sort fields, and range fields last. This allows indexes to leverage equality matches, provide non-blocking sorts, and minimize scanning. Examples show how indexes ordered by these guidelines can support queries more efficiently by narrowing the search bounds.
MongoDB .local San Francisco 2020: Aggregation Pipeline Power++MongoDB
Aggregation pipeline has been able to power your analysis of data since version 2.2. In 4.2 we added more power and now you can use it for more powerful queries, updates, and outputting your data to existing collections. Come hear how you can do everything with the pipeline, including single-view, ETL, data roll-ups and materialized views.
MongoDB .local San Francisco 2020: A Complete Methodology of Data Modeling fo...MongoDB
The document describes a methodology for data modeling with MongoDB. It begins by recognizing the differences between document and tabular databases, then outlines a three step methodology: 1) describe the workload by listing queries, 2) identify and model relationships between entities, and 3) apply relevant patterns when modeling for MongoDB. The document uses examples around modeling a coffee shop franchise to illustrate modeling approaches and techniques.
MongoDB .local San Francisco 2020: MongoDB Atlas Data Lake Technical Deep DiveMongoDB
MongoDB Atlas Data Lake is a new service offered by MongoDB Atlas. Many organizations store long term, archival data in cost-effective storage like S3, GCP, and Azure Blobs. However, many of them do not have robust systems or tools to effectively utilize large amounts of data to inform decision making. MongoDB Atlas Data Lake is a service allowing organizations to analyze their long-term data to discover a wealth of information about their business.
This session will take a deep dive into the features that are currently available in MongoDB Atlas Data Lake and how they are implemented. In addition, we'll discuss future plans and opportunities and offer ample Q&A time with the engineers on the project.
MongoDB .local San Francisco 2020: Developing Alexa Skills with MongoDB & GolangMongoDB
Virtual assistants are becoming the new norm when it comes to daily life, with Amazon’s Alexa being the leader in the space. As a developer, not only do you need to make web and mobile compliant applications, but you need to be able to support virtual assistants like Alexa. However, the process isn’t quite the same between the platforms.
How do you handle requests? Where do you store your data and work with it to create meaningful responses with little delay? How much of your code needs to change between platforms?
In this session we’ll see how to design and develop applications known as Skills for Amazon Alexa powered devices using the Go programming language and MongoDB.
MongoDB .local Paris 2020: Realm : l'ingrédient secret pour de meilleures app...MongoDB
aux Core Data, appréciée par des centaines de milliers de développeurs. Apprenez ce qui rend Realm spécial et comment il peut être utilisé pour créer de meilleures applications plus rapidement.
MongoDB .local Paris 2020: Upply @MongoDB : Upply : Quand le Machine Learning...MongoDB
Il n’a jamais été aussi facile de commander en ligne et de se faire livrer en moins de 48h très souvent gratuitement. Cette simplicité d’usage cache un marché complexe de plus de 8000 milliards de $.
La data est bien connu du monde de la Supply Chain (itinéraires, informations sur les marchandises, douanes,…), mais la valeur de ces données opérationnelles reste peu exploitée. En alliant expertise métier et Data Science, Upply redéfinit les fondamentaux de la Supply Chain en proposant à chacun des acteurs de surmonter la volatilité et l’inefficacité du marché.
13. Schema Design
Considerations
• How do we manipulate the data?
– Dynamic Ad-Hoc Queries
– Atomic Updates
– Map Reduce
• What are the access patterns of the application?
– Read/Write Ratio
– Types of Queries / Updates
– Data life-cycle and growth rate
20. One to One Relations
• Mostly the same as the relational approach
• Generally good idea to embed “contains”
relationships
• Document model provides a holistic
representation of objects
24. Book
MongoDB: The Definitive Guide,
By Kristina Chodorow and Mike Dirolf
Published: 9/24/2010
Pages: 216
Language: English
Publisher: O’Reilly Media, CA
28. Book _id as a Foreign Key
publisher = {
name: "O’Reilly Media",
founded: "1980",
location: "CA"
books: [ "123456789", ... ]
}
book = {
_id: "123456789",
title: "MongoDB: The Definitive Guide",
authors: [ "Kristina Chodorow", "Mike Dirolf" ]
published_date: ISODate("2010-09-24"),
pages: 216,
language: "English"
}
29. Where do you put the foreign
Key?
• Array of books inside of publisher
– Makes sense when many means a handful of items
– Useful when items have bound on potential growth
• Reference to single publisher on books
– Useful when items have unbounded growth (unlimited # of
books)
• SQL doesn’t give you a choice, no arrays
36. Referencing vs. Embedding
• Embedding is a bit like pre-joined data
• Document level ops are easy for server to
handle
• Embed when the “many” objects always appear
with (viewed in the context of) their parents.
• Reference when you need more flexibility
42. Modeling Trees
• Parent Links
- Each node is stored as a document
- Contains the id of the parent
• Child Links
- Each node contains the id’s of the children
- Can support graphs (multiple parents / child)
In the filing cabinet model, the patient’s x-rays, checkups, and allergies are stored in separate drawers and pulled together (like an RDBMS)In the file folder model, we store all of the patient information in a single folder (like MongoDB)
Flexibility – Ability to represent rich data structuresPerformance – Benefit from data locality
Concrete example of typical blog in typical relational normalized form
Concrete example of typical blog in typical relational normalized form
Concrete example of typical blog using a document oriented de-normalized approach
Concrete example of typical blog in typical relational normalized form
Tools for data manipulation
Tools for data access
Slow to get address data every time you query for a user. Requires an extra operation.
Patron may have two addresses, in this case, you would need a separate table in a relation databaseWith MongoDB, you simply start storing the address field as an arrayOnly patrons which have multiple addresses could have this schema!No migration necessary! but Caution: Additional application logic required!
Publisher is repeated for every book, data duplication!
Publisher is better being a separate entity and having its own collection.
Now to create a relation between the two entities, you can choose to reference the publisher from the book document.This is similar to the relational approach for this very same problem.
OR: because we are using MongoDB and documents can have arrays you can choose to model the relation by creating and maintaining an array of books within each publisher entity.Careful with mutable, growing arrays. See next slide.
Costly for a small number of books because to get the publisher
And data locality provides speed
Book’s kind attribute could be local or loanableNote that we have locations for loanable books but not for localNote that these two separate schemas can co-exist (loanable books / local books are both books)
Note that we partially de-normalize here.To get books by a particular author: - get the author - get books that have that author id in array
Simple solution. The biggest problem with this approach is getting an entire subtree requires several query turnarounds to the database
It may also be good for storing graphs where a node has multiple parents.