This document provides an introduction to MongoDB presented by Brandon Black. It describes MongoDB as a document database that is open source, high performance, and horizontally scalable. It stores data in flexible, JSON-like documents, rather than fixed schema tables. The document explains some key MongoDB concepts like documents, collections, indexing, queries and updating records. Examples are provided of creating sample data for a library application to demonstrate MongoDB's interactive and evolving schema.
This document provides an introduction and overview of MongoDB. It discusses how MongoDB is a document-oriented database that is open source, high performance, and horizontally scalable. It provides examples of using MongoDB with the mongo shell to create, query, update and index data. Key points covered include how MongoDB uses documents rather than tables, how data can be embedded or referenced between collections, and how to perform queries, sorting, pagination and more. Official drivers are available for connecting applications to MongoDB databases from many programming languages.
Building Your First App: An Introduction to MongoDBMongoDB
This document provides an introduction to MongoDB and demonstrates how to build a simple library management application using MongoDB. It discusses key MongoDB concepts like documents, collections, embedded documents, and references. It shows how to insert, query, update, and index data without needing to pre-define schemas. The document builds out a sample library application data model with books, authors, and publishers collections. It demonstrates querying, updating, paging through results and linking related data between collections. Official MongoDB drivers for various languages are also briefly mentioned.
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 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.
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.
This talk introduces the features of MongoDB by demonstrating how one can build a simple library application. The talk will cover the basics of MongoDB's document model, query language, and API.
Building Your First App: An Introduction to MongoDBMongoDB
This document provides an introduction to building a first application using MongoDB. It discusses key MongoDB concepts like using documents rather than tables, horizontal scalability, and flexible schemas. It then demonstrates common operations like inserting, querying, updating and indexing data using the MongoDB shell. Examples show creating collections for users, books, authors and related data for a library application and performing CRUD operations on the data.
This document provides an introduction to MongoDB and how to build a basic application using MongoDB. It discusses key MongoDB concepts like documents, collections, querying, indexing and references. It walks through creating collections for users, books, authors and publishers and inserting sample documents. It demonstrates basic CRUD operations and querying. The document suggests starting simply and letting the schema evolve as the application is built.
This document provides an introduction and overview of MongoDB. It discusses how MongoDB is a document-oriented database that is open source, high performance, and horizontally scalable. It provides examples of using MongoDB with the mongo shell to create, query, update and index data. Key points covered include how MongoDB uses documents rather than tables, how data can be embedded or referenced between collections, and how to perform queries, sorting, pagination and more. Official drivers are available for connecting applications to MongoDB databases from many programming languages.
Building Your First App: An Introduction to MongoDBMongoDB
This document provides an introduction to MongoDB and demonstrates how to build a simple library management application using MongoDB. It discusses key MongoDB concepts like documents, collections, embedded documents, and references. It shows how to insert, query, update, and index data without needing to pre-define schemas. The document builds out a sample library application data model with books, authors, and publishers collections. It demonstrates querying, updating, paging through results and linking related data between collections. Official MongoDB drivers for various languages are also briefly mentioned.
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 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.
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.
This talk introduces the features of MongoDB by demonstrating how one can build a simple library application. The talk will cover the basics of MongoDB's document model, query language, and API.
Building Your First App: An Introduction to MongoDBMongoDB
This document provides an introduction to building a first application using MongoDB. It discusses key MongoDB concepts like using documents rather than tables, horizontal scalability, and flexible schemas. It then demonstrates common operations like inserting, querying, updating and indexing data using the MongoDB shell. Examples show creating collections for users, books, authors and related data for a library application and performing CRUD operations on the data.
This document provides an introduction to MongoDB and how to build a basic application using MongoDB. It discusses key MongoDB concepts like documents, collections, querying, indexing and references. It walks through creating collections for users, books, authors and publishers and inserting sample documents. It demonstrates basic CRUD operations and querying. The document suggests starting simply and letting the schema evolve as the application is built.
This document discusses different design options for modeling messaging inboxes in MongoDB. It describes three main approaches: fan out on read, fan out on write, and fan out on write with bucketing. Fan out on read involves storing a single document per message with all recipients, requiring a scatter-gather query to read an inbox. Fan out on write stores one document per recipient but still involves random I/O to read an inbox. Bucketed fan out on write stores inbox messages in arrays within "inbox" documents for each user, allowing an entire inbox to be read with one or two documents. This provides the best read performance while also distributing writes across shards. The document concludes that bucketed fan out on write is typically the better
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.
MongoDB San Francisco 2013: Data Modeling Examples From the Real World presen...MongoDB
In this session, we'll examine schema design insights and trade-offs using real world examples. We'll look at three example applications: building an email inbox, selecting a shard key for a large scale web application, and using MongoDB to store user profiles. From these examples you should leave the session with an idea of the advantages and disadvantages of various approaches to modeling your data in MongoDB. Attendees should be well versed in basic schema design and familiar with concepts in the morning's basic schema design talk. No beginner topics will be covered in this session.
Building Your First App: An Introduction to MongoDBGreat Wide Open
Robert Stam gave an introduction to MongoDB and building the first app. He discussed that MongoDB is a document database that uses JSON-like documents with dynamic schemas, horizontal scaling, and high performance. He then demonstrated creating a basic library management application in MongoDB by defining entities as collections, inserting sample data, and performing queries.
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.
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 talk examines four real-world use cases for MongoDB document-based data modeling. We examine the implications of several possible solutions for each problem.
Webinar: Data Modeling Examples in the Real WorldMongoDB
This document discusses different data modeling approaches for common use cases in MongoDB. It presents four examples: an inbox with messages, retaining historical data, storing variable attributes, and supporting multiple user identities. For each, it outlines the design goals, proposes 2-3 modeling approaches, and considers the advantages and disadvantages of each in terms of write and read performance, indexing strategies, and data distribution across a sharded cluster. The conclusion emphasizes choosing a model that balances query ease with write ease while avoiding random I/O.
Building Your First MongoDB App ~ Metadata Cataloghungarianhc
These are the slides I used for a MongoDB webinar about creating your first application with MongoDB. They start with a general MongoDB overview, continuing onto how to model data for a metadata catalog. At this point in the presentation, I break to do a live demonstration. Afterwards, I touch on scaling your application with MongoDB.
Back to Basics Webinar 3 - Thinking in DocumentsJoe Drumgoole
- The document discusses modeling data in MongoDB based on cardinality and access patterns.
- It provides examples of embedding related data for one-to-one and one-to-many relationships, and references for large collections.
- The document recommends considering read/write patterns and embedding objects for efficient access, while breaking out data if it grows too large.
Back to Basics Webinar 2: Your First MongoDB ApplicationMongoDB
The document provides instructions for installing and using MongoDB to build a simple blogging application. It demonstrates how to install MongoDB, connect to it using the mongo shell, insert and query sample data like users and blog posts, update documents to add comments, and more. The goal is to illustrate how to model and interact with data in MongoDB for a basic blogging use case.
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.
Back to Basics Webinar 1 - Introduction to NoSQLJoe Drumgoole
The document provides information about an introductory webinar on NoSQL databases and MongoDB. It includes the webinar agenda which covers why NoSQL databases exist, the different types of NoSQL databases including key-value, column, graph and document stores, and details on MongoDB including how it uses JSON-like documents, ensures data durability through replica sets, and scales through sharding. It also advertises a follow up webinar on building a first MongoDB application and provides a registration link.
The document discusses four data modeling use cases: message inboxes, history retention, indexed attributes, and multiple identities. It analyzes different schema designs for each use case, considering factors like query efficiency, write performance, and how well each option supports features like sharding and indexing. The conclusion emphasizes choosing a schema that balances query needs with write workload, reduces random I/O, and is tailored to the application's key use cases.
Relational databases are central to web applications, but they have also been the primary source of pain when it comes to scale and performance. Recently, non-relational databases (also referred to as NoSQL) have arrived on the scene. This session explains not only what MongoDB is and how it works, but when and how to gain the most benefit.
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’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.
This talk introduces the features of MongoDB by demonstrating how one can build a simple library application. The talk will cover the basics of MongoDB\'s document model, query language, and API.
This document provides an introduction to MongoDB, including what it is, its key features, and how to work with documents in the MongoDB shell. MongoDB is an open-source, document-based database that is horizontally scalable, high performance, and full featured. It uses documents similar to JSON objects which can have various data structures. The document shows how to insert, query, update, and index documents using the MongoDB shell. Examples demonstrate working with collections like users, books, and authors in a sample library application. Schemas are flexible and evolve with the application's needs.
The document describes how to build an Amazon-like store using Elasticsearch. It shows how to index book and CD documents specifying the index name, type, and ID. It demonstrates searching across types and indices, and introduces the concept of indices representing different document types like books and CDs. The document provides examples of indexing, searching, and retrieving documents from Elasticsearch.
You, as a mobile software engineer always should be conscious of your apps' memory footprint. For iOS engineers, it's highly recommended to inspect Xcode Memory Graph Debugger before delivering a fix or new feature for your app or framework.
This will help you to identify:
- Memory leaks: a memory that was allocated at some point, but was never released and is no longer referenced by your app.
- Retain cycles: when two or more objects hold strong references to each other.
Fixing bugs caused by memory leaks or retain cycles is tedious, so it's better to pin them down before they occur. They are dangerous, not mentioning app crashes!
This document discusses different design options for modeling messaging inboxes in MongoDB. It describes three main approaches: fan out on read, fan out on write, and fan out on write with bucketing. Fan out on read involves storing a single document per message with all recipients, requiring a scatter-gather query to read an inbox. Fan out on write stores one document per recipient but still involves random I/O to read an inbox. Bucketed fan out on write stores inbox messages in arrays within "inbox" documents for each user, allowing an entire inbox to be read with one or two documents. This provides the best read performance while also distributing writes across shards. The document concludes that bucketed fan out on write is typically the better
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.
MongoDB San Francisco 2013: Data Modeling Examples From the Real World presen...MongoDB
In this session, we'll examine schema design insights and trade-offs using real world examples. We'll look at three example applications: building an email inbox, selecting a shard key for a large scale web application, and using MongoDB to store user profiles. From these examples you should leave the session with an idea of the advantages and disadvantages of various approaches to modeling your data in MongoDB. Attendees should be well versed in basic schema design and familiar with concepts in the morning's basic schema design talk. No beginner topics will be covered in this session.
Building Your First App: An Introduction to MongoDBGreat Wide Open
Robert Stam gave an introduction to MongoDB and building the first app. He discussed that MongoDB is a document database that uses JSON-like documents with dynamic schemas, horizontal scaling, and high performance. He then demonstrated creating a basic library management application in MongoDB by defining entities as collections, inserting sample data, and performing queries.
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.
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 talk examines four real-world use cases for MongoDB document-based data modeling. We examine the implications of several possible solutions for each problem.
Webinar: Data Modeling Examples in the Real WorldMongoDB
This document discusses different data modeling approaches for common use cases in MongoDB. It presents four examples: an inbox with messages, retaining historical data, storing variable attributes, and supporting multiple user identities. For each, it outlines the design goals, proposes 2-3 modeling approaches, and considers the advantages and disadvantages of each in terms of write and read performance, indexing strategies, and data distribution across a sharded cluster. The conclusion emphasizes choosing a model that balances query ease with write ease while avoiding random I/O.
Building Your First MongoDB App ~ Metadata Cataloghungarianhc
These are the slides I used for a MongoDB webinar about creating your first application with MongoDB. They start with a general MongoDB overview, continuing onto how to model data for a metadata catalog. At this point in the presentation, I break to do a live demonstration. Afterwards, I touch on scaling your application with MongoDB.
Back to Basics Webinar 3 - Thinking in DocumentsJoe Drumgoole
- The document discusses modeling data in MongoDB based on cardinality and access patterns.
- It provides examples of embedding related data for one-to-one and one-to-many relationships, and references for large collections.
- The document recommends considering read/write patterns and embedding objects for efficient access, while breaking out data if it grows too large.
Back to Basics Webinar 2: Your First MongoDB ApplicationMongoDB
The document provides instructions for installing and using MongoDB to build a simple blogging application. It demonstrates how to install MongoDB, connect to it using the mongo shell, insert and query sample data like users and blog posts, update documents to add comments, and more. The goal is to illustrate how to model and interact with data in MongoDB for a basic blogging use case.
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.
Back to Basics Webinar 1 - Introduction to NoSQLJoe Drumgoole
The document provides information about an introductory webinar on NoSQL databases and MongoDB. It includes the webinar agenda which covers why NoSQL databases exist, the different types of NoSQL databases including key-value, column, graph and document stores, and details on MongoDB including how it uses JSON-like documents, ensures data durability through replica sets, and scales through sharding. It also advertises a follow up webinar on building a first MongoDB application and provides a registration link.
The document discusses four data modeling use cases: message inboxes, history retention, indexed attributes, and multiple identities. It analyzes different schema designs for each use case, considering factors like query efficiency, write performance, and how well each option supports features like sharding and indexing. The conclusion emphasizes choosing a schema that balances query needs with write workload, reduces random I/O, and is tailored to the application's key use cases.
Relational databases are central to web applications, but they have also been the primary source of pain when it comes to scale and performance. Recently, non-relational databases (also referred to as NoSQL) have arrived on the scene. This session explains not only what MongoDB is and how it works, but when and how to gain the most benefit.
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’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.
This talk introduces the features of MongoDB by demonstrating how one can build a simple library application. The talk will cover the basics of MongoDB\'s document model, query language, and API.
This document provides an introduction to MongoDB, including what it is, its key features, and how to work with documents in the MongoDB shell. MongoDB is an open-source, document-based database that is horizontally scalable, high performance, and full featured. It uses documents similar to JSON objects which can have various data structures. The document shows how to insert, query, update, and index documents using the MongoDB shell. Examples demonstrate working with collections like users, books, and authors in a sample library application. Schemas are flexible and evolve with the application's needs.
The document describes how to build an Amazon-like store using Elasticsearch. It shows how to index book and CD documents specifying the index name, type, and ID. It demonstrates searching across types and indices, and introduces the concept of indices representing different document types like books and CDs. The document provides examples of indexing, searching, and retrieving documents from Elasticsearch.
You, as a mobile software engineer always should be conscious of your apps' memory footprint. For iOS engineers, it's highly recommended to inspect Xcode Memory Graph Debugger before delivering a fix or new feature for your app or framework.
This will help you to identify:
- Memory leaks: a memory that was allocated at some point, but was never released and is no longer referenced by your app.
- Retain cycles: when two or more objects hold strong references to each other.
Fixing bugs caused by memory leaks or retain cycles is tedious, so it's better to pin them down before they occur. They are dangerous, not mentioning app crashes!
This document provides an overview of getting started with MongoDB and .NET in 30 minutes or less. It discusses challenges in modeling a dynamic database in a static language like .NET, and introduces the MongoDB C# driver API including connecting to a MongoDB server, performing basic CRUD operations on documents through collections, querying, sorting, and updating documents. Additional features like connection pooling, GridFS, MapReduce, and executing JavaScript on the server are also mentioned. The document concludes by pointing to resources for downloading MongoDB and the C# driver source code, as well as support forums.
This document summarizes Exposed, an SQL toolkit for Kotlin, and provides examples of using it with Ktor. Exposed allows defining SQL schema and performing CRUD operations with a Kotlin DSL. It can connect to databases like PostgreSQL and SQLite. The examples show defining entities and tables, performing queries and migrations, and building a JSON API with Ktor. Additional resources are provided for learning more about Exposed and Ktor.
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.
This presentation was a partnership between Folger Shakespeare Library and JSTOR Labs, describing and presenting Understanding Shakespeare (http://labs.jstor.org/shakespeare), including the innovative "flash build" method of building it, in which the bulk of the work to complete the site was done in one week.
This document provides an overview of MongoDB, including that it is open-source, document-oriented, uses JSON/BSON formats, and is schemaless. It also discusses MongoDB's storage, journaling, fault tolerance using replica sets, sharding architecture, and locking mechanisms. The document recommends Martin Odersky's Coursera course on functional programming principles in Scala.
This document summarizes various AST transformations in Groovy including local transformations used in Groovy, Grails, and Griffon as well as examples of annotations like @Singleton, @Delegate, @Immutable, @Category, @Mixin, @Grab, @Log, @InheritConstructors, @Canonical, @Scalify, @Entity, @Bindable, @Listener, @EventPublisher, @Scaffold. It also provides a recipe for implementing custom AST transformations with an interface, transformation class, and annotation. Finally it mentions other types of transformations like GContracts, Spock, CodeNarc, and Griffon.
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 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.
This document summarizes Mike Harris's travels learning Clojure. It outlines the key topics covered in the log, including higher order functions, variadic functions, destructuring, and working with map structures. Code examples are provided in JavaScript, ECMAScript 6, and Clojure to demonstrate these concepts. Bibliographies of relevant conference talks, online videos, and books are also included.
Similar to Building Your First App: An Introduction to MongoDB (14)
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é.
3. MongoDB is a ___________
database
• Document
• Open source
• High performance
• Horizontally scalable
• Full featured
4. Document Database
• Not for .PDF & .DOC files
• A document is essentially an associative array
• Document == JSON object
• Document == PHP Array
• Document == Python Dict
• Document == Ruby Hash
5. Open Source
• MongoDB is an open source project
• On GitHub
• Licensed under the AGPL
• Started & sponsored by 10gen
• Commercial licenses available
• Contributions welcome
6. High Performance
• Written in C++
• Extensive use of memory-mapped files
i.e. read-through write-through memory caching.
• Runs nearly everywhere
• Data serialized as BSON (fast parsing)
• Full support for primary & secondary indexes
• Document model = less work
8. Full Featured
• Ad Hoc queries
• Real time aggregation
• Rich query capabilities
• Traditionally consistent
• Geospatial features
• Support for most programming languages
• Flexible schema
19. In a relational based app
We would start by doing
schema design
20. Relational Schema Design
• Large ERD Diagrams
• Complex create table statements
• ORMs to map tables to objects
• Tables just to join tables together
• For this simple app we'd have 5 tables and 5 join
tables
• Lots of revisions until we get it just right
21. In a MongoDB based app
We start building our
and let the schema evolve
app
27. Querying for the User
> db.users.findOne()
{
"_id" : ObjectId("50804d0bd94ccab2da652599"),
"username" : "fred.jones",
"first_name" : "fred",
"last_name" : "jones"
}
28. _id
• _id is the primary key in MongoDB
• Automatically indexed
• Automatically created as an ObjectId if not
provided
• Any unique immutable value could be used
29. ObjectId
• ObjectId is a special 12 byte value
• Guaranteed to be unique across your cluster
• ObjectId("50804d0bd94ccab2da652599")
|-------------||---------||-----||----------|
ts mac pid inc
30. Creating an Author
> db.author.insert({
first_name: 'j.r.r.',
last_name: 'tolkien',
bio: 'J.R.R. Tolkien (1892.1973), beloved throughout the
world as the creator of The Hobbit and The Lord of the Rings, was a
professor of Anglo-Saxon at Oxford, a fellow of Pembroke College,
and a fellow of Merton College until his retirement in 1959. His chief
interest was the linguistic aspects of the early English written
tradition, but even as he studied these classics he was creating a
set of his own.'
})
31. Querying for Our Author
> db.author.findOne( { last_name : 'tolkien' } )
{
"_id" : ObjectId("507ffbb1d94ccab2da652597"),
"first_name" : "j.r.r.",
"last_name" : "tolkien",
"bio" : "J.R.R. Tolkien (1892.1973), beloved throughout the world
as the creator of The Hobbit and The Lord of the Rings, was a
professor of Anglo-Saxon at Oxford, a fellow of Pembroke College,
and a fellow of Merton College until his retirement in 1959. His chief
interest was the linguistic aspects of the early English written
tradition, but even as he studied these classics he was creating a
set of his own."
}
32. Creating a Book
> db.books.insert({
title: 'fellowship of the ring, the',
author: ObjectId("507ffbb1d94ccab2da652597"),
language: 'english',
genre: ['fantasy', 'adventure'],
publication: {
name: 'george allen & unwin',
location: 'London',
date: new Date('21 July 1954'),
}
})
http://society6.com/PastaSoup/The-Fellowship-of-the-Ring-ZZc_Print/
34. Multiple Values Per Key
> db.books.findOne({genre: 'fantasy'}, {title: 1})
{
"_id" : ObjectId("50804391d94ccab2da652598"),
"title" : "fellowship of the ring, the"
}
Query key with single value or
multiple values the same way.
36. Query Nested Values with
Dot Notation
> db.books.findOne(
{'publication.date' :
{ $lt : new Date('21 June 1960')}
}
)
{
"_id" : ObjectId("50804391d94ccab2da652598"),
"title" : "fellowship of the ring, the",
"author" : ObjectId("507ffbb1d94ccab2da652597"),
"language" : "english",
"genre" : [ "fantasy", "adventure" ],
"publication" : {
"name" : "george allen & unwin",
"location" : "London",
"date" : ISODate("1954-07-21T04:00:00Z")
}
}
37. Update Books
> db.books.update(
{"_id" : ObjectId("50804391d94ccab2da652598")},
{
$set : {
isbn: '0547928211',
pages: 432
}
})
This is true agile development .
I’m simply changing how I work
with the data, and the
database follows.
45. Finding an Author by Book
> book = db.books.findOne({"title" : "return of the king, the"})
> db.author.findOne({_id: book.author})
{
"_id" : ObjectId("507ffbb1d94ccab2da652597"),
"first_name" : "j.r.r.",
"last_name" : "tolkien",
"bio" : "J.R.R. Tolkien (1892.1973), beloved throughout the world as
the creator of The Hobbit and The Lord of the Rings, was a professor of
Anglo-Saxon at Oxford, a fellow of Pembroke College, and a fellow of
Merton College until his retirement in 1959. His chief interest was the
linguistic aspects of the early English written tradition, but even as he
studied these classics he was creating a set of his own."
}
48. MongoDB Drivers
• Drivers connect to mongo servers
• Drivers translate BSON into native types
• The MongoDB shell is not a driver, but works like
one in some ways
• Installed using typical means (npm, pecl, gem,
pip)
Introduction and QuestionsHow many are currently using MongoDB?How many of you came from a relational database background?Emphasize the messagePreview of our talkLook at what makes MongoDB differentWalk through building your first application with MongoDB
Let’s talk about what we mean by this….
What do we mean by document?
AGPL – GNU Affero General Public License
* Big endian and ARM not supported.
Where can you get it?
Easy to use and interact withNo additional tools required, just jump right into the shell
Entity-relationship diagram
Kristine to update this graphic at some point
We’re going to get nerdy hereThe books on this shelf should be a strong indication of what’s to comeIf you happen to be one of his arch enemies, apologies for the appearance of Wil Wheaton’s name
Whats the first step?
Ask question: Is categories it's own entity? It could be, but it's likely a property of books.
So this is where the fun would end in a traditional relational database. Schema design slows you down. With mongodb, you do still need to think about how you want to store and access your data effectively, but there’s no up front commitment on the developers part. We can jump right into the building it.
Ask question: Is categories it's own entity? It could be, but it's likely a property of books. What are some pain points of relational db schema design?
This doesn’t mean we don’t think about schema, it just means that we let it evolve with out application. In MongoDB schemas are flexible and based on a different idea. Schemas are about how you use the data, not about how you store the data.So what kind of collections would be build in MongoDB…
Point out entities and what we end up doing them. We don’t have to normalize them.Do we want to query by publishers? Or do we just want the publisher information along without books?
I’m sure we have developers with many different backgrounds in the room today. Finding a common language would be challenging, so we’re going to use the Mongo Shell directly to build this app.
What is that _id field? I didn’t add that?
"50804d0bd94ccab2da652599" is a 24 byte string (12 byte ObjectId hex encoded).See how easy MongoDB makes this for you? Agile development etcLets get back to our app.
Powerful message here. Finally a database that enables rapid & agile development.
Creating a book here. A few things to make note of here…Author referenceGenre (List)Publication (Embedded Document)Date (new type, why not ISODate?)How would I query on genre? How do I work with keys/document fields that might have multiple values?
Specify which fields are returned. Default is everything
It’s all the same!
Feels familiar, very intuitive.How about updating the book? What if I need to add something new to this object?
Powerful message here. Finally a database that enables rapid & agile development.
You can see the updated fields here.What about indexes? Right now, we only have an index on _id because MongoDB does that for us automatically.If I don’t have to create my collection ahead of time and specify a strict schema, how do I define indexes and optimize my queries?
Creating a book here. A few things to make note of.
Creating a book here. A few things to make note of.
This is fine for small result sets. Not good performance for large result sets. Range query plus limit will give better performance.
The shell is cool and all, but how do I use MongoDB in language X?
Raise your hand if your language of choice is on this screen?