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 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 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.
Building Your First App: An Introduction to MongoDBMongoDB
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 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 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.
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.
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.
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 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.
Building Your First App: An Introduction to MongoDBMongoDB
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 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 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.
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.
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.
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.
Building Your First MongoDB ApplicationTugdual Grall
This document contains slides from a presentation on using MongoDB with Java. It introduces several Java drivers and ORM libraries for MongoDB, including the MongoDB Java driver, Morphia, Spring Data MongoDB, Jongo, and Hibernate OGM. For each library, it provides brief descriptions and examples of inserting and querying data. The presenter recommends Morphia for its easy mapping and queries, Spring Data for developers already using Spring, and Jongo for those who prefer MongoDB's query language. Hibernate OGM is noted as still being under development.
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.
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 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.
MongoDB is a scalable, high-performance, open-source document database that provides dynamic queries and indexing. It aims to provide the power of relational databases with the scalability and flexibility of non-relational databases. Key features include ease of use, scaling capabilities, dynamic queries similar to SQL, and speed comparable to key-value stores while supporting rich querying like relational databases.
The document demonstrates how to interact with CouchDB using its RESTful JSON API. It shows examples of creating, reading, updating and deleting documents through HTTP requests using curl. Specific examples include creating a database, adding a document, updating a document by including the revision ID, and retrieving a document by ID. The document also discusses CouchDB's document-oriented data model where all data is stored as JSON documents.
Indexing in MongoDB works similarly to indexing in relational databases. An index is a data structure that can make certain queries more efficient by maintaining a sorted order of documents. Indexes are created using the ensureIndex() method and take up additional space and slow down writes. The explain() method is used to determine whether a query is using an index.
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.
The document discusses using MongoDB as the data store for the "Potential Match Generator" component of an online dating service called eHarmony. Some key benefits of MongoDB cited include its scalability, built-in sharding and replication, and flexible schema. The document provides some tips for using MongoDB effectively, such as using real queries and data during testing, minimizing property names, using appropriate indexes, and considering how to shard data.
This document discusses different schema design approaches for common use cases in MongoDB. It presents four real-world examples: an inbox system, storing historical data, indexing variable attributes, and supporting multiple user identities. For each example, it analyzes the goals and considers different schema approaches like embedding documents, separating content from metadata, and bucketing or sharding data. The key lessons are to understand the access patterns needed, balance write and read performance, and avoid random I/O.
Eliot Horowitz gave a roadmap presentation at MongoSF on May 24, 2011. The presentation summarized past MongoDB releases including version 1.0 in August 2009 and version 1.8 in March 2011 which added features like journaling, indexes, and replica set enhancements. The presentation also outlined features for the upcoming version 2.0 in June 2011 including improvements to concurrency, data compaction, map/reduce performance, and new features like TTL collections and geospatial polygons. Finally, the presentation listed some high priority features for future releases such as full text search, online compaction, and a new aggregation framework.
We will provide an overview of the architecture and design of a lightweight content management system built on MongoDB. Ideally suited for managing social content -- creating a blog site, a discussion forum, or adding user generated content to an existing website -- Crafter Social is an open source Java app built on MongoDB. Our talk will focus on design considerations and MongoDB's unique features that make it perfectly suitable as a highly-scalable, multi-tenant social object store. We use MongoDB to store social objects of all types: user comments, threaded discussions, blog entries, and more. The document-oriented approach of MongoDB provides the foundation for social content management applications that need high-performance, high-scalability, and rapid speed of development. We also cover our design approach for user profile management, which supports configurable (on-the-fly) profile attributes, roles management, and pluggable authentication.
This document summarizes Giant Eagle's use of MongoDB for an expense reimbursement application. It discusses why Giant Eagle chose MongoDB over its traditional .NET/Oracle stack, the technology stack used, and MongoDB's architecture. Some limitations encountered included inability to directly select subdocuments and query across collections. Overall, while MongoDB has some immature areas, it was a good fit for the project's performance needs and flexibility.
The document discusses how MongoDB is well-suited to meet the challenges of the Intelligence Community (IC) in collecting and analyzing large amounts of data. It describes how ANTS, a product for generating simulated network traffic, was developed using MongoDB due to its scalability, flexibility, ease of use, and ability to support rapid prototyping. The document outlines upcoming new features for ANTS, including advanced scheduling capabilities and an improved user interface, and how MongoDB enables the continued evolution of ANTS.
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.
In an R&D company fast prototyping is vital to develop new projects or proofs of concept quickly and inexpensively. In this talk we will demonstrate how real fast and agile development can be achieved with MongoDB and dynamic languages, with examples and best practices. All the code shown is already uploaded to a public Git repository - https://github.com/pablito56/py-eshop
Get your Spatial on with MongoDB in the CloudMongoDB
Want to move from code to cloud in under an hour? Red Hat's OpenShift Platform-as-a-Service (PaaS) makes it easy to develop, deploy, and scale applications in the cloud. Come learn about how PaaS can make you into a happier and more productive coder. - Get started with OpenShift as the PaaS for your web application. - Deploy your first application using the command line tools or the web console. - Add and manage the MongoDB backend. - Manage application changes with Git. - Enjoy the perfect combination of OpenShift and MongoDB.
Building a High-Performance Distributed Task Queue on MongoDBMongoDB
This document discusses building a distributed job queue in MongoDB. It begins by outlining the requirements of processing tasks across multiple servers. It then describes the design of storing messages and tasks in MongoDB collections, including different message and task states. It also covers techniques like composite tasks, reducing polling through tailable cursors, and optimizing performance through retry logic and oplog replay. The overall aim is to build an asynchronous and scalable way to process jobs in a distributed manner using MongoDB.
Benjamin Paillereau gives a presentation on using MongoDB for building a chat application. He discusses why MongoDB is a good fit due to its document-oriented and flexible nature. He also covers strategies for managing lag when using MongoDB in the cloud with MongoHQ, emphasizing an asynchronous approach. Finally, he demonstrates a public chat application and offers prizes to participants who can link it with Wolfram or post the best Java code in the chat.
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.
Building Your First MongoDB ApplicationTugdual Grall
This document contains slides from a presentation on using MongoDB with Java. It introduces several Java drivers and ORM libraries for MongoDB, including the MongoDB Java driver, Morphia, Spring Data MongoDB, Jongo, and Hibernate OGM. For each library, it provides brief descriptions and examples of inserting and querying data. The presenter recommends Morphia for its easy mapping and queries, Spring Data for developers already using Spring, and Jongo for those who prefer MongoDB's query language. Hibernate OGM is noted as still being under development.
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.
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 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.
MongoDB is a scalable, high-performance, open-source document database that provides dynamic queries and indexing. It aims to provide the power of relational databases with the scalability and flexibility of non-relational databases. Key features include ease of use, scaling capabilities, dynamic queries similar to SQL, and speed comparable to key-value stores while supporting rich querying like relational databases.
The document demonstrates how to interact with CouchDB using its RESTful JSON API. It shows examples of creating, reading, updating and deleting documents through HTTP requests using curl. Specific examples include creating a database, adding a document, updating a document by including the revision ID, and retrieving a document by ID. The document also discusses CouchDB's document-oriented data model where all data is stored as JSON documents.
Indexing in MongoDB works similarly to indexing in relational databases. An index is a data structure that can make certain queries more efficient by maintaining a sorted order of documents. Indexes are created using the ensureIndex() method and take up additional space and slow down writes. The explain() method is used to determine whether a query is using an index.
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.
The document discusses using MongoDB as the data store for the "Potential Match Generator" component of an online dating service called eHarmony. Some key benefits of MongoDB cited include its scalability, built-in sharding and replication, and flexible schema. The document provides some tips for using MongoDB effectively, such as using real queries and data during testing, minimizing property names, using appropriate indexes, and considering how to shard data.
This document discusses different schema design approaches for common use cases in MongoDB. It presents four real-world examples: an inbox system, storing historical data, indexing variable attributes, and supporting multiple user identities. For each example, it analyzes the goals and considers different schema approaches like embedding documents, separating content from metadata, and bucketing or sharding data. The key lessons are to understand the access patterns needed, balance write and read performance, and avoid random I/O.
Eliot Horowitz gave a roadmap presentation at MongoSF on May 24, 2011. The presentation summarized past MongoDB releases including version 1.0 in August 2009 and version 1.8 in March 2011 which added features like journaling, indexes, and replica set enhancements. The presentation also outlined features for the upcoming version 2.0 in June 2011 including improvements to concurrency, data compaction, map/reduce performance, and new features like TTL collections and geospatial polygons. Finally, the presentation listed some high priority features for future releases such as full text search, online compaction, and a new aggregation framework.
We will provide an overview of the architecture and design of a lightweight content management system built on MongoDB. Ideally suited for managing social content -- creating a blog site, a discussion forum, or adding user generated content to an existing website -- Crafter Social is an open source Java app built on MongoDB. Our talk will focus on design considerations and MongoDB's unique features that make it perfectly suitable as a highly-scalable, multi-tenant social object store. We use MongoDB to store social objects of all types: user comments, threaded discussions, blog entries, and more. The document-oriented approach of MongoDB provides the foundation for social content management applications that need high-performance, high-scalability, and rapid speed of development. We also cover our design approach for user profile management, which supports configurable (on-the-fly) profile attributes, roles management, and pluggable authentication.
This document summarizes Giant Eagle's use of MongoDB for an expense reimbursement application. It discusses why Giant Eagle chose MongoDB over its traditional .NET/Oracle stack, the technology stack used, and MongoDB's architecture. Some limitations encountered included inability to directly select subdocuments and query across collections. Overall, while MongoDB has some immature areas, it was a good fit for the project's performance needs and flexibility.
The document discusses how MongoDB is well-suited to meet the challenges of the Intelligence Community (IC) in collecting and analyzing large amounts of data. It describes how ANTS, a product for generating simulated network traffic, was developed using MongoDB due to its scalability, flexibility, ease of use, and ability to support rapid prototyping. The document outlines upcoming new features for ANTS, including advanced scheduling capabilities and an improved user interface, and how MongoDB enables the continued evolution of ANTS.
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.
In an R&D company fast prototyping is vital to develop new projects or proofs of concept quickly and inexpensively. In this talk we will demonstrate how real fast and agile development can be achieved with MongoDB and dynamic languages, with examples and best practices. All the code shown is already uploaded to a public Git repository - https://github.com/pablito56/py-eshop
Get your Spatial on with MongoDB in the CloudMongoDB
Want to move from code to cloud in under an hour? Red Hat's OpenShift Platform-as-a-Service (PaaS) makes it easy to develop, deploy, and scale applications in the cloud. Come learn about how PaaS can make you into a happier and more productive coder. - Get started with OpenShift as the PaaS for your web application. - Deploy your first application using the command line tools or the web console. - Add and manage the MongoDB backend. - Manage application changes with Git. - Enjoy the perfect combination of OpenShift and MongoDB.
Building a High-Performance Distributed Task Queue on MongoDBMongoDB
This document discusses building a distributed job queue in MongoDB. It begins by outlining the requirements of processing tasks across multiple servers. It then describes the design of storing messages and tasks in MongoDB collections, including different message and task states. It also covers techniques like composite tasks, reducing polling through tailable cursors, and optimizing performance through retry logic and oplog replay. The overall aim is to build an asynchronous and scalable way to process jobs in a distributed manner using MongoDB.
Benjamin Paillereau gives a presentation on using MongoDB for building a chat application. He discusses why MongoDB is a good fit due to its document-oriented and flexible nature. He also covers strategies for managing lag when using MongoDB in the cloud with MongoHQ, emphasizing an asynchronous approach. Finally, he demonstrates a public chat application and offers prizes to participants who can link it with Wolfram or post the best Java code in the chat.
Business Track: How Criteo Scaled and Supported Massive Growth with MongoDBMongoDB
Criteo grew rapidly from 15 employees in 2007 to over 700 employees in 2012. They migrated from using Microsoft SQL Server to MongoDB to support their growing product catalogues and infrastructure needs. MongoDB provided a scalable distributed database that could replicate data across data centers with high availability and handle their increasing traffic of over 30 billion HTTP requests and 1 billion banners served daily. While MongoDB worked well overall, Criteo encountered some performance issues with large datasets and low read/write ratios that they had to address through optimizations.
Building Applications using MongoDB, Node.js and Socket.ioMongoDB
The document discusses using MongoDB, Node.js, and SocketIO for real-time application development. It outlines key features of each technology, including horizontal scalability, time to market advantages, and being open source. An example application described is an ad server that targets ads to viewers based on profile traits using these technologies. Code examples are provided for setting up MongoDB and Node.js, a MongoDB example, a Socket.IO example, and the overall solution architecture.
Leo Kim from Foursquare presented several hacks and tools they developed to help monitor and maintain their MongoDB deployment at scale. Some of the hacks discussed include ODash and Mongolyzer for improved MongoDB monitoring, Mackinac for automated repair of fragmented data, a shard key checker to detect queries missing shard keys, and Chunksanity to verify data integrity by checking documents are on the correct shards. Foursquare uses these internal tools to help optimize their extensive use of MongoDB sharding and replica sets supporting over 5 million check-ins per day.
This document summarizes a presentation about data management in a regulated environment. It introduces two speakers from Medtronic who discuss the challenges of making changes to applications that require FDA approval. These include needing to revalidate applications every time a change is made. The presentation then discusses why MongoDB may help, including its flexibility and performance, but that noSQL does not mean no schema. It also notes gaps that need to be addressed like enterprise acceptance of new approaches and integrating MongoDB with reporting tools and making it 21 CFR Part 11 compliant.
Eric Lubow gave a presentation on how SimpleReach fixed problems with their MongoDB implementation. They implemented a sharded replica set architecture across availability zones for high availability and speed. They improved data accuracy by separating databases and enforcing consistent access patterns. SimpleReach also implemented a controlled data flow using NSQ to batch and route data between MongoDB, Cassandra, Vertica, and other tools for analytics and real-time usage. Their architecture provides redundancy, minimal downtime for changes, and monitors performance using tools like Nagios, Statsd and Cloudwatch.
This document summarizes MongoDB Day KL 2013, a MongoDB user group meeting in Kuala Lumpur, Malaysia. It provides information about the event sponsors, speakers which included representatives from MongoDB and Says.com, and Malaysian MongoDB community leaders. An introduction to MongoDB covering its features like geo-location support, speed, replication, and schema flexibility was also outlined on the agenda.
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 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.
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.
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.
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 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 (16)
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?