undefined India | Robotic Restaurant Kitchen in Chennai

More Information

View Recipes
About MongoDB
MongoDB allows your teams to easily organize, use and enrich data – in real time, anywhere.

MongoDB is a cross-platform document-oriented database program. Classified as a NoSQL database program, MongoDB uses JSON-like documents with schemata. MongoDB is developed by MongoDB Inc. and licensed under the Server Side Public License.

MongoDB Topics

The following are the things covered under MongoDB.

MongoDB - Data Modelling
Data in MongoDB has a flexible schema.documents in the same collection. They do not need to have the same set of fields or structure, and common fields in a collection’s documents may hold different types of data.
    MongoDB - Create Collection
    In MongoDB, you don't need to create collection. MongoDB creates collection automatically, when you insert some document.
      MongoDB - Deployment
      When you are preparing a MongoDB deployment, you should try to understand how your application is going to hold up in production. It’s a good idea to develop a consistent, repeatable approach to managing your deployment environment so that you can minimize any surprises once you’re in production.
        MongoDB - Relationships
        Relationships in MongoDB represent how various documents are logically related to each other. Relationships can be modeled via Embedded and Referenced approaches. Such relationships can be either 1:1, 1:N, N:1 or N:N.
          MongoDB - Atomic Operations
          MongoDB does not support multi-document atomic transactions. However, it does provide atomic operations on a single document.
            MongoDB - Map Reduce
            As per the MongoDB documentation, Map-reduce is a data processing paradigm for condensing large volumes of data into useful aggregated results. MongoDB uses mapReduce command for map-reduce operations.

              Course Contents

              The following are the course contents offered for mongoDB

              • Datastore design considerations
              • Relational v/s NoSQL stores
              • Entities
              • When to use Relational/NoSQL?
              • Categories of NoSQL stores
              • Examples of NoSQL stores
              • MongoDB Administration
              • MongoDB Development
              • MongoDB Querying
              • MongoDB evolution
              • Major feature set for versions 1.0 and 1.2
              • Version 2
              • Version 3
              • Version 3+
              • MongoDB for SQL developers
              • MongoDB for NoSQL developers
              • MongoDB key characteristics and use cases
              • Key characteristics
              • What is the use case for MongoDB?
              • MongoDB criticism
              • MongoDB configuration and best practices
              • Operational best practices
              • Schema design best practices
              • Best practices for write durability
              • Best practices for replication
              • Best practices for sharding
              • Best practices for security
              • Best practices for AWS
              • Reference documentation
              • MongoDB documentation
              • Schema Design and Data Modeling
              • Relational schema design
              • MongoDB schema design
              • Read-write ratio
              • Connecting to MongoDB
              • Data Formats
              • What are Data Formats?
              • Difference between Data Formats and Data Structures
              • Serializing and de-serializing data
              • The JSON Data Format
              • BSON Data Format
              • Advantages of BSON
              • Servers
              • Connections
              • Databases
              • Collections
              • Documents
              • CRUD
              • Indexes
              • Query Expression Objects
              • Query Options
              • Cursors
              • Mongo Query Language
              • Dot Notation
              • Full Text Search
              • Basic Data Types
              • Dates
              • Arrays
              • _id and ObjectIds
              • Tips for Using the Shell
              • Running Scripts with the Shell
              • Creating a .mongorc.js
              • Customizing Your Prompt
              • Editing Complex Variables
              • Inconvenient Collection Names
              • Inserting Documents
              • Removing Documents
              • Updating Documents
              • Document Replacement
              • Using Update Operators
              • Upserts
              • Updating Multiple Documents
              • Returning Updated Documents
              • Introduction to find
              • Query Criteria
              • null
              • Regular Expressions
              • Querying Arrays
              • Querying on Embedded Documents
              • $where Queries
              • Limits
              • Avoiding Large Skips
              • Advanced Query Options
              • Database Commands
              • Introduction to Indexes
              • Creating an Index
              • Introduction to Compound Indexes
              • How MongoDB Selects an Index
              • Using Compound Indexes
              • How $-Operators Use Indexes
              • Indexing Objects and Arrays
              • Index Cardinality
              • When Not to Index
              • Types of Indexes
              • Index Administration
              • Joins
              • Server-side v/s Client-side querying
              • Retrieving a subset of fields
              • Conditional operators
              • Aggregation
              • Grouping
              • Projections
              • Cursor Methods
              • MapReduce introduction
              • Installing single node MongoDB
              • Starting a single node instance using command-line options
              • Single node installation of MongoDB with options from the config file
              • Connecting to a single node in the Mongo shell with JavaScript
              • Connecting to a single node using a Java client
              • Starting multiple instances as part of a replica set
              • Connecting to the replica set in the shell to query and insert data
              • Connecting to the replica set to query and insert data from a Java client
              • Connecting to the replica set to query and insert data using a Python client
              • Starting a simple sharded environment of two shards
              • Connecting to a shard in the shell and performing operations
              • Introduction
              • Creating test data
              • Performing simple querying
              • Updating and deleting data from the shell
              • Analyzing the plan
              • Improving the query execution time
              • Improvement using indexes
              • Improvement using covered indexes
              • Some caveats of index creations
              • Creating and understanding sparse indexes
              • Expiring documents after a fixed interval using the TTL index
              • Expiring documents at a given time using the TTL index
              • Basic configuration options
              • Replication
              • Master-Slave Replication
              • Adding and Removing Sources
              • Replica Sets
              • Nodes in a Replica Set
              • Using Slaves for Data Processing
              • How It Works
              • The Oplog
              • Syncing
              • Replication State and the Local Database
              • Blocking for Replication
              • Administration
              • Diagnostics
              • Changing the Oplog Size
              • Replication with Authentication
              • Renaming a collection
              • Viewing collection stats
              • Viewing database stats
              • Manually padding a document
              • The mongostat and mongotop utilities
              • Getting current executing operations and killing them
              • Using profiler to profile operations
              • Setting up users in Mongo
              • Interprocess security in Mongo
              • Modifying collection behavior using the collMod command
              • Setting up MongoDB as a windows service
              • Replica set configurations
              • shard cluster configurations
              • Setting up a Production ready Multi node cluster with 15 nodes
              • Using the Admin Interface
              • serverStatus
              • mongostat
              • Third-Party Plug-Ins
              • Authentication Basics
              • How Authentication Works
              • Other Security Considerations
              • Data File Backup
              • mongodump and mongorestore
              • fsync and Lock
              • Slave Backups
              • Repair
              • Document-oriented data
              • Principles of schema design
              • Designing an e-commerce data model
              • Nuts and bolts: on databases
              • E-commerce queries
              • MongoDB’s query language
              • Aggregating orders
              • Aggregation in detail
              • A brief tour of document updates
              • E-commerce updates
              • Atomic document processing
              • Nuts and bolts: MongoDB updates and deletes
              • Introduction
              • Atomic find and modify operations
              • Implementing atomic counters in Mongo
              • Implementing server-side scripts
              • Creating and tailing a capped collection cursors in MongoDB
              • Converting a normal collection to a capped collection
              • Storing binary data in Mongo
              • Storing large data in Mongo using GridFS
              • Storing data to GridFS from Java client
              • Implementing triggers in Mongo using oplog
              • Implementing full text search in Mongo
              • MongoDB Hadoop Integration
              • Hive Integration
              • Pig Integration
              • HandsOn UseCase Demo
              • Replica set configurations
              • shard cluster configurations
              • Setting up a Production ready Multi node cluster with 15 nodes
              • Monitoring
              • Shard cluster Administrations & perfromance monitoring
              • Troubleshoot
              • Security
              • Audit
              • x509
              • TLS/SSL
              • Alerts & monitoring
              • backup
              • Performance tuning and Optimization on MultiNode Mongodb Cluster
              • Deciding the number of mongos
              • Deciding the no of replica sets
              • Deciding the no of shards
              • Making Shards as replicasets
              • Scaling vs High Availability
              • Consistency vs Partitioning vs Performance (revisiting CAP theorem)
              • Capacity planning
              • HandsOn UseCase Demo

              Have Question?

              Contact us







              Phone:

              +91 99404 32545

              Email:

              robotickitchenindia@gmail.com

              Website:

              robochef.co