DEV Community: geetcloud

Two sum LeetCode problem explained in simple terms using Dictionary

geetcloud — Mon, 13 Sep 2021 17:16:19 +0000

Two Sum

Problem

Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

You can return the answer in any order.

Example 1:

Input: nums = [2,7,11,15], target = 9
Output: [0,1]
Output: Because nums[0] + nums[1] == 9, we return [0, 1].

Example 2:

Input: nums = [3,2,4], target = 6
Output: [1,2]

Example 3:

Input: nums = [3,3], target = 6
Output: [0,1]

Let's start

As usual, our main goal is to solve the problem and at the same time achieve the best time complexity with minimal space complexity. If you are a beginner to problem solving or trying data structure problems, I suggest you start with a brute force approach and then try to optimize your solution to the best time/space complexity.

Analysis

Before jumping into a solution or pseudocode, read the problem statement a couple of times and make sure to understand it well.
To start with, we can check each number in the array by comparing its sum with all other numbers. This will give O(\( n^2 \)) complexity with a simple brute force approach.
Let's see how we can do this better. Let's assume the two numbers we need to find are A and B. If A is the current element in our loop iteration. B is the other number in the same array. A + B = target. then, B = target - A.
How about if we could store/keep track of (target - A ) in a data structure, when we traverse each number in the array? We will only store the difference in a set, if it doesn't already exist. If it exists already, then the current indice and stored value indice are the answer. We will just return it.
Dictionary is the best data structure candidate for our solution in C#. In Java, we can go with Hashtable.

Difference between Hashtable and Dictionary in C#

Dictionary is a generic collection which is generally used to store key/value pairs. Dictionary is defined under System.Collection.Generics namespace. It is dynamic in nature which means the size of the dictionary is growing according to the need.

A Hashtable is a collection of key/value pairs that are arranged based on the hash code of the key. It is the non-generic type of collection which is defined in System.Collections namespace.

Algorithm | Pseudocode

Create a Dictionary to store the (target - currentelement)'s value in the array.
Iterate each element in the array and get the difference with target.
If the difference value already exists in the dictionary, that is our answer. Return the indices of the current element and the corresponding difference value stored in the dictionary.
Else, store the difference value in the dictionary .
At the end, throw exception "No solution found" if we don't have the difference element in our dictionary.

Let's start writing the solution.

Loop through the elements in the array. If we find the difference element in the dictionary that matches that sums up the target. That's it. That is our answer.

** Given Array contains the two indices that sums up the target !**

Solution (in C#)


    class Solution {
       public int[] TwoSum(int[] nums, int target) {
       Dictionary<int,int> dict = new Dictionary<int,int>();
        for(int i=0;i<nums.Length;i++)
        {
            int diff = target-nums[i];
            if(dict.ContainsKey(diff))
                return new int[]{dict[diff],i};
            if(!dict.ContainsKey(nums[i]))
                dict.Add(nums[i],i);
        }
        throw new Exception("No solution found");
    }
    }

Complexity

Time Complexity => O(n) => Traverse the array one time. Dictionary Add() ContainsKey operations are O(1) time.
Space Complexity => O(n) => Dictionary stores at most n number of key-value pairs.

Conclusion

This problem is a very good example of Hashtable/Dictionary Data structure usage to reduce the complexity from O(\( n^2 \)) to O(n) Do check out more examples in this category for further learning.

References

The LeetCode Problem in this article:

https://leetcode.com/problems/two-sum/

Thanks for reading this post!

I hope this article is informative and helpful in some way. If it is, please like and share!

Happy learning!

Serverless Technology Choices in Azure

geetcloud — Sun, 12 Sep 2021 06:47:19 +0000

Which Azure Serverless Technology is the best choice for your business requirements?

Overview

The objective of this article is to understand the basics and help you to choose the best Azure Serverless Technology for a general set of business requirements.

This is assuming the users who reading this article have some basic knowledge on workflow, orchestration, and application programming. If not, I would suggest those to read more on said foundation topics before you jump into this article. :)

What is Serverless Computing?

Serverless computing is a cloud-hosted execution environment with a single or group of servers that runs your code, but abstracts the underlying hosting environment. The main concept is that we are not responsible for the infrastructure or the maintenance of the server. And we don’t have to worry about the outages or increase in demand during peak instances situations like the holidays or for black friday season ;) . The cloud provider takes care of maintenance, scalability, and everything else for you.

You just create an instance of the service and add your code in any desired language. That’s it!

Today we are going to see the two most popular and commonly used Azure Serverless technologies: Azure Functions and Azure Logic Apps.

Azure Functions

With the Azure Functions service, you can host a single method or function by using a popular programming language in the cloud that runs in response to an event. An example of an event might be an HTTP request, a new message on a queue, or a message on a timer.

Functions can be written in many common programming languages, such as C#, Python, JavaScript, Typescript, Java, and PowerShell.

Key Features

Scales automatically
Charges are applied only when the function is triggered
It is the best choice when demands are variable
Perform orchestration tasks using extension called Durable functions

Azure Logic Apps

Logic Apps is a low-code/no-code development platform hosted as a cloud service. This service helps you automate and orchestrate tasks, business processes, and workflows when you need to integrate apps, data, systems, and services across enterprises or organizations

We build an app by linking triggers to actions with connectors.

A trigger is an event (such as a timer) that causes an app to execute.

An action is a task or step that can execute. (Available in different programming languages)

To build enterprise integration solutions with Azure Logic Apps, you can choose from a growing gallery of over 200 connectors. The gallery includes services such as Salesforce, SAP, Oracle DB, and file shares.

Differences

Example Use Cases

When to choose Azure Functions

Code-based, you write and test the code. Will be able to debug without involving or provisions test resources in the cloud.

If you have your code / logic / automated tasks already ready in your desired language, it is easy to just put the code in Azure Functions than to create it from scratch using Azure logic apps
If you need to perform some complex logic or specialized data parting, Azure Functions is the best since you have full control of the code and visualizing performing complex logic workflows is tough in Azure Logic Apps

When to choose Azure Logic Apps

GUI based. Preferable if we don’t want to get involved with developer resources and instead want to use GUI. Best suited for integration since lots of connectors are available out of the box.

If we need to perform more orchestration tasks from different APIs, go for Azure Logic Apps.
If we need a visual workflow, Azure Logic Apps is the best choice

Combination of both is also a best choice for large scale enterprise cloud environments.

Conclusion

In this article, we have just covered the high level overview and the differences between Azure Functions and Azure Logic Apps. Please go through the official Microsoft documentation cited in Reference section for further learning.

References

https://docs.microsoft.com/en-us/learn/modules/serverless-fundamentals/

https://docs.microsoft.com/en-us/azure/azure-functions/functions-compare-logic-apps-ms-flow-webjobs

Thanks for reading this post!

I hope this article is informative and helpful in some way. If it is, please like and share this article.

Happy learning!

LeetCode | Contains Duplicate III

geetcloud — Fri, 03 Sep 2021 19:10:48 +0000

Contains Duplicate III

Problem

Given an integer array nums and two integers k and t, return true if there are two distinct indices i and j in the array such that abs(nums[i] - nums[j]) <= t and abs(i - j) <= k.

Example 1:

Input: nums = [1,2,3,1], k = 3, t = 0
Output: true

Example 2:

Input: nums = [1,0,1,1], k = 1, t = 2
Output: true

Example 3:

Input: nums = [1,5,9,1,5,9], k = 2, t = 3
Output: false

Hint #1

Time complexity O(n log k) - This will give an indication that sorting is involved for k elements.

Hint #2

Use already existing state to evaluate next state - Like, a set of k sorted numbers are only needed to be tracked. When we are processing the next number in array, then we can utilize the existing sorted state and it is not necessary to sort next overlapping set of k numbers again.

Let's start

As usual , our main goal is to solve the problem and at the same time achieve the best time complexity with minimal space complexity. If you are a beginner to problem solving or trying data structure problems, I suggest you start with a brute force approach and then try to optimize your solution to the best time/space complexity.

Analysis

Given an integer array nums and two integers k and t, return true if there are two distinct indices i and j in the array such that abs(nums[i] - nums[j]) <= t and abs(i - j) <= k.

Before jumping into a solution or pseudocode, read the problem statement a couple of times and make sure to understand it well.
Based on the problem statement, we understand that we need to find two distinct indices i and j such that abs(nums[i] - nums[j]) <= t and abs(i - j) <= k.
This time, the problem is a moderate one and not as easy as the previous problem. So I'm going to use the hints provided. I have shared the two hints provided with the problem.
Based on the first hint, it is understood that we need to sort the elements first and then using the sorted list, we need to find if there are two distinct indices i.e satisfying the provided condition.
With sorting and iterating through all the array elements, we can achieve the solution by O(n log k) complexity.
With second hint, we understood that we need to maintain the sorted elements with its state in a data structure in such a way that we don't have to sort next overlapping elements again.
From points #4 to #6, we can definitely choose TreeSet (data structure in Java) which will be a best candidate for this problem solution.
And with all these points, we also got a hint, that this problem falls under "Sliding Window Pattern".

A sliding window is a sublist or subarray that runs over an underlying data structure. The data structure is iterable and ordered, such as an array or a string. At a high level, you can think of it as a subset of the two pointers method.

TreeSet in Java

A TreeSet is a sorted collection that extends the AbstractSet class and implements the NavigableSet interface.

It stores unique elements
It doesn't preserve the insertion order of the elements
It sorts the elements in ascending order
It's not thread-safe

In our solution, we are going to mainly use the below two important methods of Tree Set.

ceiling() => This method returns the least element in this set greater than or equal to the given element, or null if there is no such element.
floor() => This method returns the greatest element in this set less than or equal to the given element, or null if there is no such element.

So with all these hints and analysis, let's start writing our algorithm or pseudocode.

Algorithm | Pseudocode

Create a TreeSet to store the visited or tracked elements in the array.
Iterate each element in the array and get the below two values
- low => highest element in the set lesser than the current element nums[i]
- hight => smallest element in the set greater than the current element nums[i]
if ((low != null && (long) nums[i] - low <= t) || (high != null && (long) high - nums[i] <= t)) return true This means, we found the two indices that meet the required conditions.
if the conditions are not satisfied, insert the current element nums[i] in the tracking treeSet.
- if we reach (i>=k) element, we can remove the first element, since the two indices which we need to identify has to be within <=k indices.

Let's start writing the solution.

Loop through the elements in the array. If we find the two indices that matches the required condition by comparing the low & high values in the treeSet. That's it. That is our answer.
** Given Array contains Duplicate !**

Solution (in Java)


    class Solution {
        public boolean containsNearbyAlmostDuplicate(int[] nums, int k, int t) {
        TreeSet<Integer> visitedSet = new TreeSet<>();
        for (int i = 0; i < nums.length; i++) {
            Integer low = visitedSet.floor(nums[i]);
            Integer high = visitedSet.ceiling(nums[i]);
            if ((low != null && (long) nums[i] - low <= t) || (high != null && (long) high - nums[i] <= t)) {
                return true;
            }
            visitedSet.add(nums[i]);
            if (i >= k) {
                visitedSet.remove(nums[i - k]);
            }
        }
        return false;
    }
    }

Complexity

Time Complexity => O(n log k)
Space Complexity => O(k)

Conclusion

This problem is a very good example of Sliding Window Pattern. Do check out more examples in this category for further learning. Since our solution's complexity is O(n log k) , this is not the best optimized solution. Based on my research and analysis, I found that we could achieve O(n) complexity for this problem using bucket sort. But it's a little complex solution based on my understanding. So I am leaving it to readers of this article to try out the O(n) bucket sort solution as an exercise. Provide your experience on solving this problem in O(n) complexity in the comment section of this article, if interested. Let's learn from each other.

References

The LeetCode Problem in this article:

https://leetcode.com/explore/challenge/card/september-leetcoding-challenge/554/week-1-september-1st-september-7th/3446/

Thanks for reading this post!

I hope this article is informative and helpful in some way. If it is, please like and share!

Happy learning!

LeetCode | Largest Time for Given Digits

geetcloud — Thu, 02 Sep 2021 17:29:10 +0000

Largest Time for Given Digits

Problem

Given an array arr of 4 digits, find the latest 24-hour time that can be made using each digit exactly once.

24-hour times are formatted as "HH:MM", where HH is between 00 and 23, and MM is between 00 and 59. The earliest 24-hour time is 00:00, and the latest is 23:59.

Return the latest 24-hour time in "HH:MM" format. If no valid time can be made, return an empty string.

Example 1:

Input: arr = [1,2,3,4]
Output: "23:41"
Explanation: The valid 24-hour times are "12:34", "12:43", "13:24", "13:42", "14:23", "14:32", "21:34", "21:43", "23:14", and "23:41". Of these times, "23:41" is the latest.

Example 2:

Input: arr = [5,5,5,5]
Output: ""
Explanation: There are no valid 24-hour times as "55:55" is not valid.

Example 3:

Input: arr = [0,0,0,0]
Output: "00:00"

Example 4:

Input: arr = [0,0,1,0]
Output: "10:00"

Constraints:

 `arr.length == 4`
 `0 <= arr[i] <= 9`

Let's start

Our main goal is to solve the problem and at the same time achieve the best linear time complexity with minimal space complexity. If you are a beginner to problem solving or trying data structure problems, I suggest you start with a brute force approach and then try to optimize your solution to the best time/space complexity.

Analysis

Let's start analysing the problem statement. Given the array of 4 digits, we need to find out the latest 24-hour time that can be made using each digit "only once".

Before jumping into a solution or pseudocode, read the problem statement a couple of times and make sure to understand it well.
Based on the problem statement, we understand that we need to compute all the possible combinations of the four digits to find the answer. This will give us a hint immediately that this problem falls under "Dynamic Programming". It's a very interesting topic to learn all the different approaches to tackle these kind of similar "Permutation & Combination" problems.

Try to identify the keywords like "each digit" can be used "only once". This is our first clue. We exactly have four digits to make our "hh:mm" latest hour (final answer).
Second clue we can think of is to check each digit or hold the digit occurrences of all hh:mm combinations to compare with the array to get our final answer.
Since we want the latest hour, max hour and minute in a day (24 hour time format) we need to start from the max (23 hr and 59 minute respectively) and iterate backwards to get the latest hour.

So with all these hints and analysis, let's start writing our algorithm or pseudocode.

Algorithm | Pseudocode

Start iterating from the max hour:minute max time (23:59) and hold all of the 4 digits combinations for each iteration
Initialise a latest_hour boolean flag at the start to "true".
If the 4 digits of the single iteration not matching with the 4 elements of the input array, we have not reached the latest_hour. So set the latest_hour flag to false.
Iterate and continue till we find the latest hour. i.e until the 4 digits combinations match with the 4 elements of the array.

Let's start writing the solution.

Loop through every hour and digit combination. If we find the exact
four array elements. That's it. That is our answer.
The Latest 24-hour Time!

Solution (in Java)

    class Solution {
        public String largestTimeFromDigits(int[] arr) {
          for(int hour = 23; hour >= 0; hour--) {
                for(int minute = 59; minute >= 0; minute--) {
                    boolean latest_hour = true;
                    int[] count = new int[10];

                    count[hour < 10 ? 0 : hour / 10]++;
                    count[hour < 10 ? hour : hour % 10]++;
                    count[minute < 10 ? 0 : minute / 10]++;
                    count[minute < 10 ? minute : minute % 10]++;                

                   for(int item : arr) {
                        if(--count[item] < 0) {
                            latest_hour = false;
                            break;
                        }
                    }

                    if(latest_hour) 
                      return String.format("%02d:%02d", hour, minute);
                }
            }
            return "";
        }
    }

Complexity

Time Complexity => O(23 x 59 x 4) ==> O(1)
Space Complexity => O(1)

Conclusion

This problem is a very good example of Dynamic Programing. Do check out for more examples in this category for further learning. Dynamic Programming has two methods, Top-down and Bottom-up approach. Be on the lookout for a future article where I explain the two and their differences!

References

The LeetCode Problem in this article:

https://leetcode.com/problems/largest-time-for-given-digits/

Thanks for reading this post!

I hope this article is informative and helpful in some way. If it is, please like and share!

Happy learning!

Relational Data Services in Azure - PaaS, IaaS, Hybrid & IoT

geetcloud — Wed, 01 Sep 2021 15:26:43 +0000

In this article, we are going to see all of the Relational Data Services that are available in Azure

Infrastructure as a service (IaaS) - SQL Server on VMs

Platform as a Service (PaaS) - Azure SQL Database , Azure SQL Managed
Instance, Azure Database for MySQL, PostgreSQL & MariaDB.

For Hybrid On-Premise extension - SQL Stretch Database

For IoT - Azure SQL Edge

SQL Server on Azure VM

With SQL Server on Azure VM, on-premise SQL workloads can be easily shifted to Azure while maintaining complete SQL Server compatibility and operating system-level access.

Key Features

Infrastructure as Service (IaaS) with a complete set of features.
Requires no code changes except the connection string.
Full control over the server in the cloud as similar to on-premise server.
Leverage existing expertise in SQL Server and continue working the same way as on the on-premise server.

Azure SQL Database

Azure SQL Database is the most preferred solution for normal relational and transactional databases. Azure provides the option to create a database server and deploy our databases to the cloud. A SQL Database server is a logical construct that acts as a central administrative point for multiple single or pooled databases, logins, firewall rules, auditing rules, threat detection policies, and failover groups. Azure SQL Database is available with several options: Single Database, Elastic Pool, and Managed Instance.

Azure SQL Managed Instance

Azure SQL Database restricts some of the administrative features available in SQL Server. Within Azure SQL Managed Instance, we have full control over the instance, as much as you would for an on-premises server. We can deploy as many as databases we want in the server.

With the support of other Azure Services, managed instance automates backups, software updates, monitoring etc., it is always up-to-date.

Key Features

Easy lift and shift - Fully-fledged SQL instance with 100% compatibility with on-premise instance.
- Fully Managed PaaS service with a complete set of features.
Enhanced Security and isolation with VNet and a private IP address.

Azure Database for MySQL

MySQL is the leading open source relational database for Linux, Apache, MySQL, and PHP (LAMP) stack apps.

Azure Database for MySQL based on the MySQL free community edition offers high availability and elastic scaling to open-source mobile and web apps or migrate MySQL workloads to the cloud.

Key Features

Built-in high availability features
Enhanced security with compliance
Automatic backups and point-in-time restore for up to 35 days
Easy scaling option
Pay-as-you-go pricing - only pay for what you use.
Offers integration with Azure App Services and Azure Kubernete Services for simplified development

Azure Database for PostgreSQL

Azure PostgreSQL helps in building scalable, secure, and fully managed enterprise-ready apps on open-source PostgreSQL, scale out single-node PostgreSQL with high performance, or migrate PostgreSQL and Oracle workloads to the cloud.

Key Features

Offers extensions which MySQL does not have
PostgreSQL Extensions provides additional custom data types, functions, JSONB, full text-search, index types, language-types, caching, geospatial support etc.,
Supports geometric data such as lines, circles and polygons
Supports both relational and non-relational data
Provides high performance horizontal scaling using Hyperscale (Citus)

Similarities with MySQL

Both are Open Source, and support relational database and fully managed services.
Makes it easier to lift and shift your applications to Azure
No need to convert your datastore to SQL Server or SQL Database
Use the same tools as SQL Database for scaling and monitoring
Intelligent Performance Recommendations
Enhanced Security Capabilities

Azure Maria DB

MariaDB is a newer database management system, created by the original developers of MySQL.

Key Features

Built-in support for temporal data. A table can hold several versions of data, enabling an application to query the data as it appeared at some point in the past
Offers compatibility with Oracle Database

Azure MariaDB based on free community edition offers high availability and elastic scaling to open-source mobile and web apps with a managed community MariaDB database service

Key Features of Azure MariaDB

Relational Database as a fully managed service
High Availability
Scaling as needed within seconds
Automatic backups and point-in-time restore for up to 35 days
Support for many languages and frameworks
Enhanced Security Capabilities with Azure IP Advantage

Hybrid Database using SQL Server Stretch DB

Scenarios where we choose to go for the hybrid option

When you have an existing database that is running out of space
When you have an on premise server with large database running lot of applications
To retain existing Traditional Architecture of Legacy system. The hardest option out of the rest.
For these scenarios, upgrading to a new server might be difficult and painful. One option would be to extend "cool" data to the cloud, so we can extend the life of the on premise server.

Using Stretch Database, data can be split between on-premises storage and cloud storage. We can push the cold, historical data to the cloud (which will be accessed rarely) and warm active data can be retained on-premises to boost the performance.

Azure SQL Edge

Azure SQL Edge is an optimized relational database engine that is specially designed for IoT and IoT Edge deployments.

Key Features

Able to create excellent data storage and processing layer for different IoT applications.
Since it is built on top of the SQL Server database engine, we can use the same T-SQL programming in SQL Server
Provides the most demanding machine learning and artificial intelligence capabilities
Its built-in streaming capability helps you with complex event processing and realtime analytics

Conclusion

This time, we covered the Relational data store related services that are available in Azure. Stay tuned to learn more about other types of data stores in Azure, as this is just the beginning.

References

Thanks for reading this post!

I hope this article is informative and helpful in some way. If it is, please like and share this article.

Happy learning!

Azure Cosmos DB | Mongo DB - Embedding vs Reference

geetcloud — Mon, 30 Aug 2021 01:46:55 +0000

Schema-less Databases similar to Mongo DB help us design models, store and query data easily and rapidly. But it is very important to understand, design and create the right schema design for your application which has great impact on the performance, scalability, costs etc.

Below are the key factors we need to consider before start designing our data models in Mongo DB.

Understand the difference between Normalized/Relational database to a Schema-less Mongo/Azure Cosmos DB
Is our application read or write heavy
How to model data in a schema-less database?
In which scenarios we need to embed data and which scenarios we need to refer to data?

Embedding data model pattern

As a developer/architect, when we start working in a schema-less database, we always tend to design schema similar to relational or normalized database. We would like to design the data into multiple tables as we traditionally design in a SQL normalized database but we would miss the great advantages of Mongo DB.

So it is better to understand the difference between traditional Normalized/Relational Database and Schema-less database.

For example, in a relational schema design, developers design the schema independent of queries. will normalize the data into multiple entities to avoid storing redundant data on each record and rather refer to the data in the related entities.

In the below example, it illustrates how we model order data in a relational database.

Order Data - Schema Design in Relational Database

To query the order, item details, contact details, etc, we need to make joins to other tables and fetch the data.

In the same manner, to update a single order item details, we need to update multiple tables.

Let's see how we can design the same order data model in Mongo / Azure Cosmos DB.

  { 
“id”: “1”, 
“orderdate”: “02/08/2021”,
“tax” : “8”,
“subtotalbeforetax”: “69”,
“shipmentdate”: “03/08/2021”,
“orderitems”: [ 
 { 
  “itemname”: “item1”,
  “quantity”: “2”,
  “itemprice”: “12”,
  “totalprice”:”24" 
 },
 { “itemname”: “item2”,
   “quantity”: “3”,
   “itemprice”: “15”,
   “totalprice”: “45”
 } 
],
“shippingcontact”: [ 
 {
   “name”: “<<person1>>”,
   “street”: “<<street1>>”,
   “city”: “<<city1>>”, 
   “state”: “<<state1>>”,
   “country”: “<<country1>>”, 
   “zipcode”: “<<zipcode1>>”,
   “phone”: “<<street1>>”
 },
]
 “billingcontact”: [ 
 {
  “name”: “<<person1>>”,
  “street”: “<<street1>>”,
  “city”: “<<city1>>”, 
  “state”: “<<state1>>”,
  “country”: “<<country1>>”,
  “zipcode”: “<<zipcode1>>”,
  “phone”: “<<street1>>”
 },
] 
}

In the above json document , we have denormalized order data by embedding all the data related to the order such as line item details, shipping and billing contact details etc., into a single document.

We are also flexible to change any fields or the sub objects/arrays format entirely anytime.

Now we can retrieve the complete order details in a single query/ read operation against a single embedded document.

Same way, updating the order with the item details and shipping information also can be done in a single update/write operation against the single order document.

In general, it is always recommended to go for Embed. Except for some specific cases where we need to go for Reference. Embedding also improves query-read performance.

Reference data model pattern

As long as we have less data to embed, we are good with Embedding Schema design. For one-one and one-few relationship entities, Embedding Data model pattern is the best choice.

But if we have too much data to embed, for one-many relationship entities where the child documents can grow above the limit or where the data might change frequently, it is better to go Referencing data model pattern.

For example, a library product catalog can have "n" number of book items which keep changing on a daily basis and it can experience growth regularly.

Product_Catalog:

“Product_Catolog” : 
{ 
  “id”: “1”, 
  “libraryname”: “<<libraryname>>”, 
  “product_catalog_no”: “1234”, 
  “books”: [“BookId(‘1111’)”, “BookId(‘2222’)”, “BookId(‘3333’)”] 
}

Books:

“books” :[ 
 { 
   “_id” : “Id(‘1111’)”, 
   “title” : “Book 1111”, 
   “author” : “Author 1111”, 
   “qty”: “10”, 
   “price”:” 24.99" 
 } 
 { 
   “_id” : “Id(‘2222’)”, 
   “title” : “Book 2222”, 
   “author” : “Author 2222”, 
   “qty”: “15”, 
   “price”:” 30.99" 
 } 
 { 
   “_id” : “Id(‘3333’)”, 
   “title” : “Book 3333”, 
   “author” : “Author 3333”, 
   “qty”: “20”, 
   “price”:” 14.99" 
 } 
]

In the above example, our book documents are independent of the parent product_catalog document. Any changes to the book documents can be updated separately.

Another key examples for frequent data updates are weather, stock exchange etc., where we can expect changes consistently. For these examples, embedding data model pattern may not be a good choice.

In a nutshell, there are different ways we can model our data in Mongo DB by embedding data or by referencing documents similar to normalizing data in SQL.

By using these two data model patterns, we can make efficient, scalable and powerful queries to documents that are completely very useful and impactful for your applications.

Based on my learning and experience, I have only touched a bit about Embedding and Referencing schema designs. There are still lot to read and learn about all different one-one, one-few, one-many, many-many relationship examples to know more detail about these data model patterns and best practices.

Please check out the official Mongo DB and Azure Cosmos DB documentation for further learning.

Thanks for reading this post!

I hope this article is informative and helpful in some way. If it is, please like and share this article.

Happy learning!

"npm" Command Cheat Sheet

geetcloud — Sun, 29 Aug 2021 21:21:57 +0000

Welcome back to a new blog post. Throughout my uses of npm and creating applications in angular, I have found a set of commands that I keep coming back to to use again and again. While they're all used very commonly, it might be heard to remember them all of the time. So without any further ado, here they are for your convenient use! Hope it helps.

To install node.js

 # To install node.js
 # Install from the below official download link.
 # https://nodejs.org/en/#download

To install typescript

# To install typescript
npm install typescript -g

To install angular CLI

#  To install angular CLI
npm install @angular/cli -g

To check angular version

# To check angular version
ng version

To check the existing installed paths of node.js

# To check the existing installed paths of node.js
where node

To create new angular app

# To create new angular app
ng new <app_name>

To create module

# To create module
ng g module <module_name>

To install dependencies

# To install dependencies
npm install

To run or serve app

# To run/serve app
#To serve app => cd to the app folder and run
#Note:- npm start also will call ng serve and start the application.
ng serve

To create service

# To create service
ng gnerate service service_name

To generate interface

# To generate interface
ng generate interface git-search

To install latest AngularFire and Firebase for latest Angular CLI 7.x

# To install latest AngularFire and Firebase for latest Angular CLI 7.x
npm install firebase @angular/fire --save

To skip/avoid long path in terminal (shortcut)

# To skip/avoid long path in terminal (shortcut)
prompt $$

Thanks for reading this post!

I hope this article is informative and helpful in some way. If it is, please like and share this article.

Happy learning!