Skip to main content

NoSQL

🌐 8. NoSQL Databases​

79. What is NoSQL?​

NoSQL āĻšāϞ⧋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŽā§āϝāĻžāύ⧇āϜāĻŽā§‡āĻ¨ā§āϟ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āϰ āĻāĻ•āϟāĻŋ āφāϧ⧁āύāĻŋāĻ• āĻĒāĻĻā§āϧāϤāĻŋ, āϝāĻž āĻĒā§āϰāĻĨāĻžāĻ—āϤ (traditional) āϰāĻŋāϞ⧇āĻļāύāĻžāϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ (RDBMS) āĻāϰ āĻŽāϤ⧋ āĻĄā§‡āϟāĻžāϕ⧇ āĻŸā§‡āĻŦāĻŋāϞ, āϰ⧋ (row), āĻāĻŦāĻ‚ āĻ•āϞāĻžāĻŽā§‡āϰ āĻĢāĻŋāĻ•ā§āϏāĻĄ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ⧇ āϏ⧇āĻ­ āĻ•āϰ⧇ āύāĻžāĨ¤ āĻāϟāĻŋ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇ āĻŦāĻŋāĻĒ⧁āϞ āĻĒāϰāĻŋāĻŽāĻžāĻŖ āφāύāĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāĻ°ā§āĻĄ (Unstructured) āĻŦāĻž āϏ⧇āĻŽāĻŋ-āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāĻ°ā§āĻĄ (Semi-structured) āĻĄā§‡āϟāĻž āϖ⧁āĻŦ āĻĻā§āϰ⧁āϤ āĻāĻŦāĻ‚ āĻĢā§āϞ⧇āĻ•ā§āϏāĻŋāĻŦāϞ āωāĻĒāĻžāϝāĻŧ⧇ āĻšā§āϝāĻžāĻ¨ā§āĻĄā§‡āϞ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝāĨ¤

āϏāĻšāϜ āĻ•āĻĨāĻžāϝāĻŧ, āφāĻĒāύāĻŋ āϝāĻ–āύ āϜāĻžāύ⧇āύ āύāĻž āφāĻĒāύāĻžāϰ āĻĄā§‡āϟāĻžāϰ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ āϕ⧇āĻŽāύ āĻšāĻŦ⧇, āĻ…āĻĨāĻŦāĻž āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύ āφāĻĒāύāĻžāϰ āĻĄā§‡āϟāĻžāϰ āĻ­āϞāĻŋāωāĻŽ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āĻŦāĻžāĻĄāĻŧāϛ⧇ āϝāĻž āĻāĻ•āϟāĻŋ āϏāĻŋāĻ™ā§āϗ⧇āϞ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āϰāĻžāĻ–āĻž āϏāĻŽā§āĻ­āĻŦ āύāϝāĻŧ, āϤāĻ–āύ NoSQL āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

Technical definition: NoSQL (often interpreted as "Not Only SQL") is a broad class of non-relational database management systems that do not rely on rigid schemas (like traditional SQL databases) and are specifically designed to be distributed, highly scalable, and capable of handling massive volumes of structured, semi-structured, and unstructured data.

How does it differ from relational databases?​

NoSQL āĻāĻŦāĻ‚ SQL āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻŦ⧇āĻļ āĻ•āĻŋāϛ⧁ āĻŽā§ŒāϞāĻŋāĻ• āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āϰāϝāĻŧ⧇āϛ⧇:

FeatureSQL Databases (RDBMS)NoSQL Databases
Data Storage ModelāĻŸā§‡āĻŦāĻŋāϞ-āĻ­āĻŋāĻ¤ā§āϤāĻŋāĻ• (Rows and Columns)āĨ¤ āĻĄā§‡āϟāĻž āϰāĻŋāϞ⧇āĻļāύāĻžāϞ āĻŽāĻĄā§‡āϞ⧇ āĻĨāĻžāϕ⧇āĨ¤Document, Key-Value, Graph, āĻŦāĻž Wide-column āĻ¸ā§āĻŸā§‹āϰ⧇āϜ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āĨ¤
SchemaRigid/Fixed SchemaāĨ¤ āĻĄā§‡āϟāĻž āϏ⧇āĻ­ āĻ•āϰāĻžāϰ āφāϗ⧇āχ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ āĻ āĻŋāĻ• āĻ•āϰāϤ⧇ āĻšā§Ÿ (Schema-on-write)āĨ¤Dynamic/Flexible SchemaāĨ¤ āϝ⧇āϕ⧋āύ⧋ āϏāĻŽāϝāĻŧ āύāϤ⧁āύ āĻĢāĻŋāĻ˛ā§āĻĄ āϝ⧋āĻ— āĻ•āϰāĻž āϝāĻžāϝāĻŧ (Schema-on-read)āĨ¤
Scaling StrategyVertical Scaling (Scale-up) - āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ RAM, CPU āĻŦāĻžāĻĄāĻŧāĻžāϤ⧇ āĻšāϝāĻŧāĨ¤Horizontal Scaling (Scale-out) - āϏāĻ¸ā§āϤāĻž āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϝ⧋āĻ— āĻ•āϰ⧇ āĻ•ā§āϝāĻžāĻĒāĻžāϏāĻŋāϟāĻŋ āĻŦāĻžāĻĄāĻŧāĻžāύ⧋ āϝāĻžāϝāĻŧāĨ¤
ACID vs BASEACID (Atomicity, Consistency, Isolation, Durability) āĻ—ā§āϝāĻžāϰāĻžāĻ¨ā§āϟāĻŋ āĻĻā§‡ā§ŸāĨ¤BASE (Basically Available, Soft state, Eventual consistency) āĻŽāĻĄā§‡āϞ āĻŽā§‡āύ⧇ āϚāϞ⧇āĨ¤
Relationships/JoinsForeign key āĻāĻŦāĻ‚ Complex JOINs āϏāĻžāĻĒā§‹āĻ°ā§āϟ āĻ•āϰ⧇āĨ¤āĻĄā§‡āϟāĻž āĻĄāĻŋāύāĻ°ā§āĻŽāĻžāϞāĻžāχāϜāĻĄ (Denormalized) āĻĨāĻžāϕ⧇, āϤāĻžāχ āϏāĻžāϧāĻžāϰāĻŖāϤ JOIN āϏāĻžāĻĒā§‹āĻ°ā§āϟ āĻ•āϰ⧇ āύāĻž āĻŦāĻž āĻ•āϰāϞ⧇āĻ“ āϖ⧁āĻŦ āϏ⧀āĻŽāĻŋāϤāĨ¤

When should you choose NoSQL over SQL?​

āφāĻĒāύāĻžāϰ āĻĒā§āϰāĻœā§‡āĻ•ā§āĻŸā§‡ NoSQL āĻŦ⧇āϛ⧇ āύ⧇āĻ“āϝāĻŧāĻž āωāϚāĻŋāϤ āϝāĻ–āύ āύāĻŋāĻšā§‡āϰ āĻĒāϰāĻŋāĻ¸ā§āĻĨāĻŋāϤāĻŋāϗ⧁āϞ⧋ āĻĻ⧇āĻ–āĻž āϝāĻžā§Ÿ:

  • ā§§. āĻŦāĻŋāĻļāĻžāϞ āĻĄā§‡āϟāĻž āĻ­āϞāĻŋāωāĻŽ (Huge Data Growth): āφāĻĒāύāĻžāϰ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϝāĻĻāĻŋ āĻĒā§āϰāϤāĻŋāĻĻāĻŋāύ āĻŸā§‡āϰāĻžāĻŦāĻžāχāϟ āĻ¸ā§āϤāϰ⧇āϰ āĻĄā§‡āϟāĻž āĻœā§‡āύāĻžāϰ⧇āϟ āĻ•āϰ⧇ (āϝ⧇āĻŽāύ: āϏ⧋āĻļā§āϝāĻžāϞ āĻŽāĻŋāĻĄāĻŋāϝāĻŧāĻž āĻĢāĻŋāĻĄ, āφāχāĻ“āϟāĻŋ āϏ⧇āĻ¨ā§āϏāϰ⧇āϰ āĻĄā§‡āϟāĻž), āϤāĻŦ⧇ āĻāϟāĻŋ āĻšāϰāĻŋāϜāĻ¨ā§āϟāĻžāϞ āĻ¸ā§āϕ⧇āϞāĻŋāĻ‚āϝāĻŧ⧇āϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϏāĻšāĻœā§‡ āĻšā§āϝāĻžāĻ¨ā§āĻĄā§‡āϞ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤
  • ⧍. āĻ¸ā§āĻ•āĻŋāĻŽāĻžāϤ⧇ āĻŦāĻžāϰāĻŦāĻžāϰ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ (Frequent Schema Changes): āϝāĻ–āύ āφāĻĒāύāĻžāϰ āĻĄā§‡āϟāĻžāϰ āϕ⧋āύ⧋ āĻĢāĻŋāĻ•ā§āϏāĻĄ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ āύ⧇āχ (Agile development)āĨ¤ āϝ⧇āĻŽāύ: āχ-āĻ•āĻŽāĻžāĻ°ā§āϏ⧇ āĻāϕ⧇āĻ• āĻĒā§āϰ⧋āĻĄāĻžāĻ•ā§āĻŸā§‡āϰ āĻāϕ⧇āĻ• āϰāĻ•āĻŽ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ (āĻ•ā§āϝāĻžāĻŽā§‡āϰāĻžāϰ āϞ⧇āĻ¨ā§āϏ āϏāĻžāχāϜ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻļāĻžāĻ°ā§āĻŸā§‡āϰ āϏāĻžāχāϜ) āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤
  • ā§Š. āωāĻšā§āϚ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻ“ āĻ¸ā§āĻĒāĻŋāĻĄ (High Performance): āǰāĻŋāϝāĻŧ⧇āϞ-āϟāĻžāχāĻŽ āϗ⧇āĻŽāĻŋāĻ‚, āϞāĻžāχāĻ­ āĻšā§āϝāĻžāϟ, āĻŦāĻž āϰāĻŋāϝāĻŧ⧇āϞ-āϟāĻžāχāĻŽ āĻāύāĻžāϞāĻžāχāϟāĻŋāĻ•ā§āϏ āϝ⧇āĻ–āĻžāύ⧇ āĻĢā§āĻ°ā§āϝāĻžāĻ•āĻļāύ-āĻ…āĻĢ-āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡ āϰāĻŋāĻĄ/āϰāĻžāχāϟ āϰ⧇āϏāĻĒāĻ¨ā§āϏ āĻĒā§āϰāϝāĻŧā§‹āϜāύāĨ¤
  • ā§Ē. āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āφāĻ°ā§āĻ•āĻŋāĻŸā§‡āĻ•āϚāĻžāϰ (Distributed Architecture): āϝāĻ–āύ āφāĻĒāύāĻžāϰ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽāϕ⧇ āĻŦāĻŋāĻļā§āĻŦ⧇āϰ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ āĻĒā§āϰāĻžāĻ¨ā§āϤ⧇āϰ āĻĄā§‡āϟāĻž āϏ⧇āĻ¨ā§āϟāĻžāϰ⧇ āĻĄā§‡āϟāĻž āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāϟ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ āĻāĻŦāĻ‚ āϏāĻŋāĻ™ā§āϗ⧇āϞ āĻĒāϝāĻŧ⧇āĻ¨ā§āϟ āĻ…āĻĢ āĻĢ⧇āχāϞāĻŋāϝāĻŧāϰ (Single Point of Failure) āĻā§œāĻžāϤ⧇ āĻšāϝāĻŧāĨ¤

80. Types of NoSQL databases?​

NoSQL āϕ⧋āύ⧋ āĻāĻ•āĻ• āĻĒā§āϰāϝ⧁āĻ•ā§āϤāĻŋāϰ āύāĻžāĻŽ āύāϝāĻŧ; āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āĻ›āĻžāϤāĻž-āĻĒāϰāĻŋāĻ­āĻžāώāĻž (Umbrella term)āĨ¤ āĻĄā§‡āϟāĻž āĻ¸ā§āĻŸā§‹āϰ āĻ•āϰāĻžāϰ āĻĒāĻĻā§āϧāϤāĻŋāϰ āĻ“āĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ NoSQL āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϕ⧇ āĻĒā§āϰāϧāĻžāύāϤ ā§ĒāϟāĻŋ āĻļā§āϰ⧇āĻŖāĻŋāϤ⧇ āĻ­āĻžāĻ— āĻ•āϰāĻž āϝāĻžā§ŸāĨ¤

Give examples of each type (document, key-value, column-family, graph)?​

ā§§. Document-oriented Database​

āĻāĻ–āĻžāύ⧇ āĻĄā§‡āϟāĻžāϕ⧇ JSON, BSON āĻŦāĻž XML āĻĢāϰāĻŽā§‡āĻŸā§‡ "āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āϟ" āĻšāĻŋāϏ⧇āĻŦ⧇ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āϟ āĻ¸ā§āĻŦāϝāĻŧāĻ‚āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āĻāĻŦāĻ‚ āĻāĻĻ⧇āϰ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāϤ⧋ āφāϞāĻžāĻĻāĻž āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

  • āωāĻĻāĻžāĻšāϰāĻŖ: MongoDB, CouchDB, Amazon DocumentDB.

⧍. Key-Value Store​

āĻāϟāĻŋ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϏāϰāϞ NoSQL āĻŽāĻĄā§‡āϞāĨ¤ āĻāĻ–āĻžāύ⧇ āĻĄā§‡āϟāĻžāϕ⧇ āĻāĻ•āϟāĻŋ āĻĄāĻŋāĻ•āĻļāύāĻžāϰāĻŋāϰ (Dictionary) āĻŽāϤ⧋ āϰāĻžāĻ–āĻž āĻšāϝāĻŧ, āϝ⧇āĻ–āĻžāύ⧇ āĻāĻ•āϟāĻŋ āχāωāύāĻŋāĻ• Key āĻāϰ āĻŦāĻŋāĻĒāϰ⧀āϤ⧇ āĻāĻ•āϟāĻŋ Value āĻĨāĻžāϕ⧇āĨ¤ āĻ­ā§āϝāĻžāϞ⧁āϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖ āĻŸā§‡āĻ•ā§āϏāϟ āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇ āĻāĻ•āϟāĻŋ āφāĻ¸ā§āϤ āĻ…āĻŦāĻœā§‡āĻ•ā§āϟ āĻŦāĻž JSON āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

  • āωāĻĻāĻžāĻšāϰāĻŖ: Redis, Amazon DynamoDB, Memcached, Riak.

ā§Š. Column-family Store (Wide-column)​

āĻāϟāĻŋ āĻĄā§‡āϟāĻžāϕ⧇ āϏāĻžāϰāĻŋ (Row) āĻāϰ āĻŦāĻĻāϞ⧇ āĻ•āϞāĻžāĻŽ (Column) āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ—ā§āϰ⧁āĻĒ āĻ•āϰ⧇ āϰāĻžāϖ⧇āĨ¤ āĻāϟāĻŋ āĻŦāĻŋāĻļāĻžāϞ āĻĒāϰāĻŋāĻŽāĻžāĻŖ āĻĄā§‡āϟāĻžāϰ āĻ“āĻĒāϰ āĻĻā§āϰ⧁āϤ āϰāĻžāχāϟ (Write) āĻ…āĻĒāĻžāϰ⧇āĻļāύ āĻ•āϰāϤ⧇ āϖ⧁āĻŦ āĻĒāĻžāϰāĻĻāĻ°ā§āĻļā§€āĨ¤

  • āωāĻĻāĻžāĻšāϰāĻŖ: Apache Cassandra, HBase, ScyllaDB.

ā§Ē. Graph Database​

āĻ—ā§āϰāĻžāĻĢ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĄā§‡āϟāĻžāϰ āĻšā§‡āϝāĻŧ⧇āĻ“ āĻĄā§‡āϟāĻžāϰ āĻŽāĻ§ā§āϝāĻ•āĻžāϰ āϏāĻŽā§āĻĒāĻ°ā§āĻ• (Relationship) āĻāϰ āĻ“āĻĒāϰ āĻŦ⧇āĻļāĻŋ āĻœā§‹āϰ āĻĻ⧇āϝāĻŧāĨ¤ āĻāĻ–āĻžāύ⧇ āĻĄā§‡āϟāĻžāϕ⧇ "Node" āĻāĻŦāĻ‚ āϏāĻŽā§āĻĒāĻ°ā§āĻ•āϕ⧇ "Edge" āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĒā§āϰāĻ•āĻžāĻļ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤

  • āωāĻĻāĻžāĻšāϰāĻŖ: Neo4j, Amazon Neptune, ArangoDB.

Which type fits which use case?​

āϕ⧋āύ āĻĒā§āϰāĻœā§‡āĻ•ā§āĻŸā§‡ āϕ⧋āύ āϟāĻžāχāĻĒ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ⧇āύ āϤāĻž āύāĻŋāĻ°ā§āĻ­āϰ āĻ•āϰ⧇ āχāωāϜ āϕ⧇āϏ⧇āϰ āĻ“āĻĒāϰ:

Database TypePerfect For (Use Cases)Real-world Example
DocumentContent Management Systems (CMS), E-commerce Catalogs, User Profiles, Blogging platformsāĻĒā§āϰ⧋āĻĢāĻžāχāϞ āĻĄāĻžāϟāĻž āϝ⧇āĻ–āĻžāύ⧇ āχāωāϜāĻžāϰ⧇āϰ āϏ⧋āĻļā§āϝāĻžāϞ āϞāĻŋāĻ‚āĻ•, āĻāĻĄā§āϰ⧇āϏ āϏāĻŦ āĻāĻ• āϜāĻžā§ŸāĻ—āĻžā§Ÿ JSON āĻĢāĻ°ā§āĻŽā§‡āĻŸā§‡āϰ āĻŽāϤ⧋ āϰāĻžāĻ–āϤ⧇ āĻšā§ŸāĨ¤
Key-ValueSession Management, User Preferences, Shopping Carts, In-memory CachingāχāωāϜāĻžāϰ āϞāĻ—āχāύ āĻ•āϰāĻžāϰ āĻĒāϰ āϏ⧇āĻļāύ āφāχāĻĄāĻŋ āĻĻāĻŋā§Ÿā§‡ āĻĻā§āϰ⧁āϤ āϤāĻžāϰ āĻĄāĻŋāĻŸā§‡āϞāϏ āφāύāĻž (āĻ•ā§āϝāĻžāĻļāĻŋāĻ‚)āĨ¤
Column-familyTime-series data, Event logs, IoT Sensor Data, Fraud detectionāĻāĻ•āϟāĻŋ āĻ“āϝāĻŧ⧇āĻŦāϏāĻžāχāĻŸā§‡āϰ āϞāĻžāĻ– āϞāĻžāĻ– āχāωāϜāĻžāϰ⧇āϰ āĻ•ā§āϞāĻŋāĻ• āĻ¸ā§āĻŸā§āϰāĻŋāĻŽ (Click-stream) āĻšāĻŋāĻ¸ā§āĻŸā§āϰāĻŋ āĻāĻ•āϏāĻžāĻĨ⧇ āϜāĻŽāĻŋā§Ÿā§‡ āϰāĻžāĻ–āĻžāĨ¤
GraphSocial Networks (Friends connection), Recommendation Engines, Fraud Rings"āϕ⧇ āĻ•āĻžāϕ⧇ āĻšā§‡āύ⧇" āĻŦāĻž "āϝāĻŋāύāĻŋ āĻāχ āĻ˛ā§āϝāĻžāĻĒāϟāĻĒ āĻ•āĻŋāύ⧇āϛ⧇āύ, āϤāĻŋāύāĻŋ āφāϰ āĻ•āĻŋ āĻ•āĻŋ āĻŽāĻžāωāϏ āĻ•āĻŋāύ⧇āϛ⧇āύ"—āĻ āϧāϰāύ⧇āϰ āĻĄāĻŋāĻĒ āϰāĻŋāϞ⧇āĻļāύ āĻŦ⧇āϰ āĻ•āϰāĻžāĨ¤

81. What is a key-value store?​

Key-value store āĻšāϞ⧋ NoSQL āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϏāϰāϞ āĻāĻŦāĻ‚ āĻĢāĻžāĻ¸ā§āĻŸā§‡āĻ¸ā§āϟ āϟāĻžāχāĻĒāĨ¤ āĻāϟāĻŋ āĻŽā§‚āϞāϤ āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻļāĻžāϞ āĻšā§āϝāĻžāĻļ āĻŸā§‡āĻŦāĻŋāϞ (Hash Table) āĻŦāĻž āĻĄāĻŋāĻ•āĻļāύāĻžāϰāĻŋ (Dictionary) āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ āϰ⧇āĻ•āĻ°ā§āĻĄ āĻāĻ•āϟāĻŋ āχāωāύāĻŋāĻ• Key (āϝ⧇āĻŽāύ āφāχāĻĄāĻŋ āĻŦāĻž āύāĻžāĻŽ) āĻāĻŦāĻ‚ āϤāĻžāϰ āϏāĻžāĻĨ⧇ āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻŋāϤ āĻāĻ•āϟāĻŋ Value āĻĻāĻŋāϝāĻŧ⧇ āĻ—āĻ āĻŋāϤ āĻšāϝāĻŧāĨ¤

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āχāĻžā§āϜāĻŋāύ⧇āϰ āĻ•āĻžāϛ⧇ 'Value' āĻ…āĻ‚āĻļāϟāĻŋ āĻāĻ•āϟāĻŋ āĻŦā§āĻ˛ā§āϝāĻžāĻ•-āĻŦāĻ•ā§āϏ (Black Box)āĨ¤ āχāĻžā§āϜāĻŋāύ āĻļ⧁āϧ⧁ 'Key' āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āĻĄā§‡āϟāĻž āϤ⧁āϞ⧇ āφāύ⧇, 'Value' āĻāϰ āϭ⧇āϤāϰ⧇āϰ āĻĄā§‡āϟāĻž āύāĻŋāϝāĻŧ⧇ āϏ⧇ āϕ⧋āύ⧋ āĻĢāĻŋāĻ˛ā§āϟāĻžāϰāĻŋāĻ‚ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤

Technical definition: A Key-Value store is a simple database model designed for storing, retrieving, and managing associative arrays where each record is securely identified by a unique key. It optimizes specifically for highly concurrent and extremely fast read/write operations by retrieving data directly via primary keys.

Examples like Redis, DynamoDB?​

  • Redis (Remote Dictionary Server): āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āϜāύāĻĒā§āϰāĻŋāϝāĻŧ āχāύ-āĻŽā§‡āĻŽāϰāĻŋ (In-memory) āϕ⧀-āĻ­ā§āϝāĻžāϞ⧁ āĻ¸ā§āĻŸā§‹āϰāĨ¤ āĻŽā§‡āĻŽāϰāĻŋāϤ⧇ āĻĄā§‡āϟāĻž āϰāĻžāĻ–āĻžāϰ āĻ•āĻžāϰāϪ⧇ āĻāϟāĻŋ āϏāĻžāϧāĻžāϰāĻŖ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϤ⧁āϞāύāĻžāϝāĻŧ āϗ⧁āĻŖāĻ—āϤāĻ­āĻžāĻŦ⧇ āĻ…āύ⧇āĻ• āĻĢāĻžāĻ¸ā§āϟ (āĻŽāĻŋāϞāĻŋāϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡āϰ āĻšā§‡āϝāĻŧ⧇āĻ“ āĻ•āĻŽ āϏāĻŽāϝāĻŧ⧇ āϰ⧇āϏāĻĒāĻ¨ā§āϏ āĻĻ⧇āϝāĻŧ)āĨ¤ āĻāϟāĻŋ āĻŽā§‚āϞāϤ Caching, Session store, āĻāĻŦāĻ‚ Rate limiting āĻāϰ āϜāĻ¨ā§āϝ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤

  • Amazon DynamoDB: āĻāϟāĻŋ AWS āĻāϰ āĻāĻ•āϟāĻŋ āĻĢ⧁āĻ˛ā§āϞāĻŋ-āĻŽā§āϝāĻžāύ⧇āϜāĻĄ (Fully managed) āϏāĻžāĻ°ā§āĻ­āĻžāϰāϞ⧇āϏ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāĨ¤ āϝāĻĻāĻŋāĻ“ āĻāϟāĻŋ āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āĻŸā§‡āϰ āĻŽāϤ⧋ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āĻāϰ āϕ⧋āϰ āφāĻ°ā§āĻ•āĻŋāĻŸā§‡āĻ•āϚāĻžāϰ āĻāĻ•āϟāĻŋ āĻšāĻžāχāĻĒāĻžāϏ-āĻ¸ā§āϕ⧇āϞāĻĄ āϕ⧀-āĻ­ā§āϝāĻžāϞ⧁ āĻ¸ā§āĻŸā§‹āϰāĨ¤ āϗ⧇āĻŽāĻŋāĻ‚ āϞ⧇āĻĄāĻžāϰāĻŦā§‹āĻ°ā§āĻĄ āĻŦāĻž āĻļāĻĒāĻŋāĻ‚ āĻ•āĻžāĻ°ā§āĻŸā§‡āϰ āĻŽāϤ⧋ āĻšāĻžāχ-āĻŸā§āϰāĻžāĻĢāĻŋāĻ• āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡ āĻāϟāĻŋ āĻĻāĻžāϰ⧁āĻŖ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

What are the limitations?​

āϕ⧀-āĻ­ā§āϝāĻžāϞ⧁ āĻ¸ā§āĻŸā§‹āϰ⧇āϰ āĻŦ⧇āĻļ āĻ•āĻŋāϛ⧁ āĻŦāĻĄāĻŧ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž āφāϛ⧇:

ā§§. Complex Queries āĻ•āϰāĻž āϝāĻžāϝāĻŧ āύāĻž: āφāĻĒāύāĻŋ āĻļ⧁āϧ⧁ Key āĻĻāĻŋāϝāĻŧ⧇ āĻĄā§‡āϟāĻž āϖ⧁āρāϜāϤ⧇ āĻĒāĻžāϰāĻŦ⧇āύāĨ¤ āφāĻĒāύāĻŋ āϝāĻĻāĻŋ āĻŦāϞ⧇āύ, "āĻ“āχāϏāĻŦ āχāωāϜāĻžāϰāĻĻ⧇āϰ āĻĻāĻžāĻ“ āϝāĻžāĻĻ⧇āϰ āĻŦ⧟āϏ ⧍ā§Ģ āĻāϰ āĻŦ⧇āĻļāĻŋ"—āϕ⧀-āĻ­ā§āϝāĻžāϞ⧁ āĻ¸ā§āĻŸā§‹āϰ āϤāĻž āĻĒāĻžāϰāĻŦ⧇ āύāĻž, āĻ•āĻžāϰāĻŖ āϏ⧇ āĻ­ā§āϝāĻžāϞ⧁āϰ āϭ⧇āϤāϰ⧇āϰ āĻ…āĻ‚āĻļ āĻĒā§œā§‡ āĻĢāĻŋāĻ˛ā§āϟāĻžāϰ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻžāĨ¤

⧍. No Relationships (No Joins): āĻĻ⧁āϟāĻŋ āĻ­āĻŋāĻ¨ā§āύ āĻĄā§‡āϟāĻžāϰ āĻŽāĻ§ā§āϝ⧇ āϕ⧋āύ⧋ āĻĢāϰ⧇āύ-āϕ⧀ (Foreign Key) āĻŦāĻž āϰāĻŋāϞ⧇āĻļāύāĻļāĻŋāĻĒ āĻŽā§‡āχāύāĻŸā§‡āχāύ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĻŦāĻŋāϧāĻž āύ⧇āχāĨ¤ āϜāϝāĻŧ⧇āύāĻŋāĻ‚ āĻāϰ āĻ•āĻžāϜ āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϞ⧇āϭ⧇āϞ⧇ (Backend code) āĻŽā§āϝāĻžāύ⧁āϝāĻŧāĻžāϞāĻŋ āĻ•āϰāϤ⧇ āĻšāϝāĻŧāĨ¤

ā§Š. Partial Updates āĻ•āĻ āĻŋāύ: āϏāĻžāϧāĻžāϰāĻŖāϤ āĻĒ⧁āϰ⧋ āĻ­ā§āϝāĻžāϞ⧁āϟāĻžāϕ⧇ āĻŽā§‡āĻŽāϰāĻŋāϤ⧇ āĻāύ⧇ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻ•āϰ⧇ āφāĻŦāĻžāϰ āĻĒ⧁āϰ⧋āϟāĻžāϕ⧇ āϰāĻŋāĻĒā§āϞ⧇āϏ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ (Update the whole object)āĨ¤ āϝāĻĻāĻŋāĻ“ Redis-āĻāϰ āĻŽāϤ⧋ āĻ•āĻŋāϛ⧁ āĻ¸ā§āĻŸā§‹āϰ āĻĒāĻžāĻ°ā§āĻļāĻŋāϝāĻŧāĻžāϞ āφāĻĒāĻĄā§‡āϟ āϏāĻžāĻĒā§‹āĻ°ā§āϟ āĻ•āϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϰāĻŋāϞāĻžāĻļāύāĻžāϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻŽāϤ⧋ āϏāĻšāϜ āύāϝāĻŧāĨ¤


82. What is a document database?​

Document database āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ• āϧāϰāϪ⧇āϰ NoSQL āĻĄāĻžāϟāĻžāĻŦ⧇āϏ, āϝāĻž āĻĄā§‡āϟāĻžāϕ⧇ āĻŸā§‡āĻŦāĻŋāϞ⧇āϰ āĻŦāĻĻāϞ⧇ JSON (āĻŦāĻž BSON/XML) āĻāϰ āĻŽāϤ⧋ "āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āϟ" āφāĻ•āĻžāϰ⧇ āϏ⧇āĻ­ āĻ•āϰ⧇āĨ¤ āĻāĻ–āĻžāύ⧇ āĻĒā§āϰāϤāĻŋāϟāĻŋ āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āϟ āĻāĻ•āϟāĻŋ āĻ¸ā§āĻŦāϝāĻŧāĻ‚āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āϰ⧇āĻ•āĻ°ā§āĻĄ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇, āϝāĻžāϰ āϭ⧇āϤāϰ⧇ āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āϏāĻžāĻŦ-āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āϟ āĻŦāĻž āĻ…ā§āϝāĻžāϰ⧇ (Array) āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āϏāĻšāϜ āĻ•āĻĨāĻžāϝāĻŧ, āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϕ⧋āĻĄā§‡ (āϝ⧇āĻŽāύ JavaScript āĻ Object āĻŦāĻž Python āĻ Dictionary) āĻĄā§‡āϟāĻž āϝ⧇āĻ­āĻžāĻŦ⧇ āĻšā§āϝāĻžāĻ¨ā§āĻĄā§‡āϞ āĻ•āϰāĻž āĻšāϝāĻŧ, āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āĻ…āĻŦāĻŋāĻ•āϞ āϏ⧇āĻ­āĻžāĻŦ⧇āχ āĻĄā§‡āϟāĻž āϏ⧇āĻ­ āĻšāϝāĻŧāĨ¤

Technical definition: A document-oriented database is a computer program and data storage system designed for storing, retrieving, and managing document-oriented information directly aligning with object-oriented programming methodologies, typically using JSON-like formats.

Why is MongoDB considered schema-less?​

MongoDB āϕ⧇ schema-less (āϞ⧁āϜāϞāĻŋ "Dynamic Schema") āĻŦāϞāĻž āĻšāϝāĻŧ āĻ•āĻžāϰāĻŖ, RDBMS āĻāϰ āĻŽāϤ⧋ āĻĄā§‡āϟāĻž āĻĸā§‹āĻ•āĻžāύ⧋āϰ āφāϗ⧇ āφāĻĒāύāĻžāϕ⧇ āϕ⧋āύ⧋ āĻŸā§‡āĻŦāĻŋāϞ āĻĄāĻŋāϜāĻžāχāύ āĻŦāĻž āĻ•āϞāĻžāĻŽ āĻĄāĻŋāĻ•ā§āϞ⧇āϝāĻŧāĻžāϰ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ āύāĻžāĨ¤ āĻāĻ•āχ "Collection" (āϝāĻž āĻŸā§‡āĻŦāĻŋāϞ⧇āϰ āϏāĻŽāϤ⧁āĻ˛ā§āϝ) āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻĨāĻžāĻ•āĻž āĻ­āĻŋāĻ¨ā§āύ āĻ­āĻŋāĻ¨ā§āύ āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āĻŸā§‡āϰ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ āφāϞāĻžāĻĻāĻž āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āωāĻĻāĻžāĻšāϰāĻŖāĻ¸ā§āĻŦāϰ⧂āĻĒ: āϧāϰāĻž āϝāĻžāĻ• āĻāĻ•āϟāĻŋ users āĻ•āĻžāϞ⧇āĻ•āĻļāύ⧇ āφāĻĒāύāĻŋ āύāĻŋāĻšā§‡āϰ āĻĻ⧁āϟāĻŋ āĻ­āĻŋāĻ¨ā§āύ āĻ¸ā§āĻŸā§āϰāĻžāĻ•āϚāĻžāϰ⧇āϰ āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āϟ āϰāĻžāĻ–āϤ⧇ āĻĒāĻžāϰāĻŦ⧇āύ āϕ⧋āύ⧋ āĻāϰāϰ āĻ›āĻžāĻĄāĻŧāĻžāχ:

// User 1 (Minimal data)
{
"_id": ObjectId("64a1b2c3d4..."),
"name": "āĻ•āϰāĻŋāĻŽ",
"email": "karim@email.com"
}

// User 2 (Complex data in the same collection)
{
"_id": ObjectId("64a1b2c3d5..."),
"name": "āϰāĻšāĻŋāĻŽ",
"phone": "017XXXXXXX",
"blood_group": "O+",
"address": {
"city": "Dhaka",
"zip": "1000"
},
"hobbies": ["Cricket", "Reading"]
}

āĻāĻ–āĻžāύ⧇ āĻĒā§āϰāĻĨāĻŽ āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āĻŸā§‡ āĻāĻĄā§āϰ⧇āϏ āĻŦāĻž āĻšāĻŦāĻŋ āύ⧇āχ, āĻāĻŦāĻ‚ āĻāϰ āϜāĻ¨ā§āϝ āϕ⧋āύ⧋ NULL āĻ•āϞāĻžāĻŽāĻ“ āϤ⧈āϰāĻŋ āĻšāϝāĻŧāύāĻŋāĨ¤ āϝāĻ–āύ āϝ⧇āĻ­āĻžāĻŦ⧇ āϖ⧁āĻļāĻŋ āύāϤ⧁āύ āĻĢāĻŋāĻ˛ā§āĻĄ āĻāĻĄ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤

How do you handle relationships in document stores?​

āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āϟ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āϜāϝāĻŧ⧇āύ (JOIN) āĻ•āϰāĻž āϖ⧁āĻŦ āĻāĻ•ā§āϏāĻĒ⧇āĻ¨ā§āϏāĻŋāĻ­ āĻŦāĻž āϏāĻŦ āϏāĻŽāϝāĻŧ āϏāĻžāĻĒā§‹āĻ°ā§āϟ āĻ•āϰ⧇ āύāĻžāĨ¤ āϤāĻžāχ āϰāĻŋāϞ⧇āĻļāύāĻļāĻŋāĻĒ āĻŽā§‡āχāύāĻŸā§‡āχāύ āĻ•āϰāϤ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻĻ⧁āϟāĻŋ āĻĒā§āϝāĻžāϟāĻžāĻ°ā§āύ āĻĢāϞ⧋ āĻ•āϰāĻž āĻšāϝāĻŧ:

ā§§. Embedding (Denormalization - "One-to-Few"):​

āϝāĻ–āύ āĻāĻ•āϟāĻŋ āĻāĻ¨ā§āϟāĻŋāϟāĻŋāϰ āϏāĻžāĻĨ⧇ āϏāĻŽā§āĻĒāĻ°ā§āĻ•āĻŋāϤ āĻĄā§‡āϟāĻž āϖ⧁āĻŦ āĻŦ⧇āĻļāĻŋ āĻŦāĻĄāĻŧ āĻšāϝāĻŧ āύāĻž, āϤāĻ–āύ āϰāĻŋāϞ⧇āĻŸā§‡āĻĄ āĻĄā§‡āϟāĻžāϕ⧇ āĻŽā§‚āϞ āĻĄāϕ⧁āĻŽā§‡āĻ¨ā§āĻŸā§‡āϰ āϭ⧇āϤāϰ⧇āχ (Embedded array āĻŦāĻž sub-document āĻšāĻŋāϏ⧇āĻŦ⧇) āĻĸ⧁āĻ•āĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤

  • āωāĻĻāĻžāĻšāϰāĻŖ: āĻāĻ•āϟāĻŋ āĻŦā§āϞāϗ⧇āϰ āĻĒā§‹āĻ¸ā§āϟ āĻāĻŦāĻ‚ āϤāĻžāϰ ā§§ā§Ļ-⧍ā§ĻāϟāĻŋ āĻ•āĻŽā§‡āĻ¨ā§āϟāĨ¤
{
"_id": 101,
"title": "NoSQL Guide",
"content": "Deep dive into NoSQL...",
"comments": [
{"user": "āφāϞ⧀", "text": "āϖ⧁āĻŦ āϏ⧁āĻ¨ā§āĻĻāϰ āĻĒā§‹āĻ¸ā§āϟ!"},
{"user": "āϰāĻžāύāĻž", "text": "āϧāĻ¨ā§āϝāĻŦāĻžāĻĻāĨ¤"}
]
}
  • āϏ⧁āĻŦāĻŋāϧāĻž: āĻāĻ•āϟāĻŋāĻŽāĻžāĻ¤ā§āϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϕ⧁āϝāĻŧ⧇āϰāĻŋāϤ⧇āχ āĻĒā§‹āĻ¸ā§āϟ āĻāĻŦāĻ‚ āĻ•āĻŽā§‡āĻ¨ā§āϟ āϏāĻŦ āĻāĻ•āϏāĻžāĻĨ⧇ āϞ⧋āĻĄ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ (āĻĻā§āϰ⧁āϤ Read)āĨ¤

⧍. Referencing (Normalization - "One-to-Many" or "Many-to-Many"):​

āϝāĻ–āύ āϰāĻŋāϞ⧇āĻŸā§‡āĻĄ āĻĄā§‡āϟāĻž āĻ…āύ⧇āĻ• āĻŦāĻĄāĻŧ āĻšāϤ⧇ āĻĒāĻžāϰ⧇ āĻŦāĻž āĻŦāĻžāϰāĻŦāĻžāϰ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻšāϝāĻŧ, āϤāĻ–āύ āĻĄā§‡āϟāĻžāϕ⧇ āφāϞāĻžāĻĻāĻž āĻ•āĻžāϞ⧇āĻ•āĻļāύ⧇ āϰāĻžāĻ–āĻž āĻšāϝāĻŧ āĻāĻŦāĻ‚ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āϤāĻžāϰ _id (āϰ⧇āĻĢāĻžāϰ⧇āĻ¨ā§āϏ) āϏ⧇āĻ­ āĻ•āϰ⧇ āϰāĻžāĻ–āĻž āĻšāϝāĻŧ (Foreign Key āĻāϰ āĻŽāϤ⧋)āĨ¤

  • āωāĻĻāĻžāĻšāϰāĻŖ: āĻāĻ•āϟāĻŋ āĻĒāĻžāĻŦāϞāĻŋāĻļāĻžāϰ āĻāĻŦāĻ‚ āϤāĻžāϰ āĻšāĻžāϜāĻžāϰ āĻšāĻžāϜāĻžāϰ āĻŦāχāĨ¤
// Publisher Document
{
"_id": "pub_1",
"name": "Tech Books BD"
}

// Books Document
{
"_id": "book_1",
"title": "Learn MongoDB",
"publisher_id": "pub_1" // Reference
}
  • āϏ⧁āĻŦāĻŋāϧāĻž: āĻĄā§‡āϟāĻž āĻĄā§āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻšāϝāĻŧ āύāĻž āĻāĻŦāĻ‚ āϞāĻžāĻ°ā§āϜ āĻ¸ā§āϕ⧇āϞ āĻĄā§‡āϟāĻž āĻšā§āϝāĻžāĻ¨ā§āĻĄā§‡āϞ āĻ•āϰāĻž āϏāĻšāϜ āĻšāϝāĻŧāĨ¤ (MongoDB āϤ⧇ āĻāϗ⧁āϞ⧋ āĻœā§‹ā§œāĻž āϞāĻžāĻ—āĻžāύ⧋āϰ āϜāĻ¨ā§āϝ $lookup āĻāĻ—ā§āϰāĻŋāϗ⧇āĻļāύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšā§Ÿ)āĨ¤

83. What is a column-family database?​

Column-family database āϗ⧁āϞ⧋ āĻĄā§‡āϟāĻžāϕ⧇ āϏāĻžāϰāĻŋ (Row) āĻāϰ āĻŦāĻĻāϞ⧇ āĻ•āϞāĻžāĻŽ (Column) āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ¸ā§āĻŸā§‹āϰ āĻ•āϰ⧇āĨ¤ āĻāĻ–āĻžāύ⧇ āĻ•āϞāĻžāĻŽāϗ⧁āϞ⧋āϕ⧇ "Column Families" āύāĻžāĻŽāĻ• āĻ—ā§āϰ⧁āĻĒ⧇ āĻ­āĻžāĻ— āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻāϟāĻŋ āĻāĻŽāύāĻ­āĻžāĻŦ⧇ āĻĄāĻŋāϜāĻžāχāύ āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇ āϝ⧇āύ āĻāĻ•āχ āϧāϰāύ⧇āϰ āĻĄā§‡āϟāĻž āĻĢāĻŋāϜāĻŋāĻ•ā§āϝāĻžāϞāĻŋ āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āϕ⧇āϰ āĻāĻ•āχ āϜāĻžāϝāĻŧāĻ—āĻžāϝāĻŧ āĻĨāĻžāϕ⧇, āϝāĻž āĻŦāĻŋāĻļāĻžāϞ āĻĒāϰāĻŋāĻŽāĻžāĻŖ āĻĄā§‡āϟāĻžāϰ āĻ“āĻĒāϰ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻĻā§āϰ⧁āϤ āϰāĻŋāĻĄāĻŋāĻ‚ āĻāĻŦāĻ‚ āϰāĻžāχāϟāĻŋāĻ‚ āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰ⧇āĨ¤

Technical definition: A wide-column store (or column-family database) is a two-dimensional key-value store where rows and columns form the keys, and the resulting multi-dimensional map is partitioned across multiple nodes for extreme scalability and write-throughput.

How is Cassandra different from traditional RDBMS?​

Apache Cassandra āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻ–ā§āϝāĻžāϤ āĻ•āϞāĻžāĻŽ āĻĢā§āϝāĻžāĻŽāĻŋāϞāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāĨ¤ RDBMS āĻāϰ āϏāĻžāĻĨ⧇ āĻāϰ āĻŦāĻŋāĻļāĻžāϞ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āϰāϝāĻŧ⧇āϛ⧇:

FeatureTraditional RDBMS (e.g., MySQL)Apache Cassandra
ArchitectureMaster-Slave (āĻāĻ•āϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻŽā§‚āϞ, āĻŦāĻžāĻ•āĻŋāϗ⧁āϞ⧋ āĻ•āĻĒāĻŋ)āĨ¤Peer-to-Peer (āϏāĻŦ āύ⧋āĻĄ āϏāĻŽāĻžāύ)āĨ¤ āϕ⧋āύ⧋ Single Point of Failure āύ⧇āχāĨ¤ āĻŽāĻžāĻ¸ā§āϟāĻžāϰ āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰāĻžāϰ āĻ­āϝāĻŧ āύ⧇āχāĨ¤
Storage EngineB-Tree (āĻ­āĻžāϞ⧋ Read āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻāϰ āϜāĻ¨ā§āϝ)āĨ¤LSM-Tree (Log-Structured Merge-Tree)āĨ¤ āĻāϟāĻŋ āĻŽā§‚āϞāϤ āĻŦāĻŋāĻļāĻžāϞ āĻĒāϰāĻŋāĻŽāĻžāĻŖ Write āĻ…āĻĒāĻžāϰ⧇āĻļāύ⧇āϰ āϜāĻ¨ā§āϝ āĻ…āĻĒā§āϟāĻŋāĻŽāĻžāχāϜāĻĄāĨ¤
ScalingVertical (RAM/CPU āĻŦāĻžā§œāĻžāĻ“), Horizontal āĻ¸ā§āϕ⧇āϞāĻŋāĻ‚ āĻ•āĻ āĻŋāύāĨ¤Linear Horizontal ScalingāĨ¤ āϝāϤāϗ⧁āϞ⧋ āύāϤ⧁āύ āύ⧋āĻĄ/āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϝ⧋āĻ— āĻ•āϰāĻŦ⧇āύ, āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āϤāϤ āϗ⧁āĻŖ āĻŦāĻžāĻĄāĻŧāĻŦ⧇āĨ¤
QueryingComplex JOIN, GROUP BY, ORDER BY āϏāĻžāĻĒā§‹āĻ°ā§āϟ āĻ•āϰ⧇āĨ¤No JoinsāĨ¤ āϕ⧁āϝāĻŧ⧇āϰāĻŋ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ Partition Key āĻāϰ āĻ“āĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āĻšāϝāĻŧāĨ¤
FlexibilityRigid SchemaāĨ¤ āϏāĻŦ āϰ⧋-āϤ⧇ āϏāĻŽāĻžāύ āĻ•āϞāĻžāĻŽ āĻĨāĻžāĻ•āϤ⧇ āĻšāĻŦ⧇āĨ¤FlexibleāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ āϰ⧋-āϤ⧇ āφāϞāĻžāĻĻāĻž āϏāĻ‚āĻ–ā§āϝāĻ• āĻ•āϞāĻžāĻŽ āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

What is wide column store?​

āĻāĻ•āϟāĻŋ Wide column store āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŸā§‡āĻŦāĻŋāϞ āϝ⧇āĻ–āĻžāύ⧇ āĻāĻ•āϟāĻŋ āύāĻŋāĻ°ā§āĻĻāĻŋāĻˇā§āϟ āϰ⧋ (Row) āĻāϰ āφāĻ¨ā§āĻĄāĻžāϰ⧇ āĻ•āϝāĻŧ⧇āĻ• āĻĄāϜāύ āĻĨ⧇āϕ⧇ āĻļ⧁āϰ⧁ āĻ•āϰ⧇ āĻ•āϝāĻŧ⧇āĻ• āĻŽāĻŋāϞāĻŋāϝāĻŧāύ (Million) āĻĒāĻ°ā§āϝāĻ¨ā§āϤ āĻĄāĻžāχāύāĻžāĻŽāĻŋāĻ• āĻ•āϞāĻžāĻŽ āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āϏāĻžāϧāĻžāϰāĻŖ āϰāĻŋāϞ⧇āĻļāύāĻžāϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āφāĻĒāύāĻŋ āϝāĻĻāĻŋ ā§§ā§Ļā§Ļā§ĻāϟāĻŋ āĻ•āϞāĻžāĻŽ āĻŦāĻžāύāĻžāύ āĻāĻŦāĻ‚ āĻ…āύ⧇āĻ• āϰ⧋ āϤ⧇ āϏ⧇āϗ⧁āϞ⧋ āĻĢāĻžāρāĻ•āĻž (NULL) āĻĨāĻžāϕ⧇, āϤāĻŦ⧇ āϤāĻž āĻĒā§āϰāϚ⧁āϰ āĻ¸ā§āĻŸā§‹āϰ⧇āϜ āĻ¸ā§āĻĒ⧇āϏ āύāĻˇā§āϟ āĻ•āϰ⧇āĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ Wide Column Store āĻ, āϝ⧇ āĻ•āϞāĻžāĻŽā§‡ āĻĄā§‡āϟāĻž āύ⧇āχ, āϤāĻžāϰ āϕ⧋āύ⧋ āĻ…āĻ¸ā§āϤāĻŋāĻ¤ā§āĻŦāχ āύ⧇āχ (Sparse Data)āĨ¤

āωāĻĻāĻžāĻšāϰāĻŖ: āĻāĻ•āϟāĻŋ āχāϭ⧇āĻ¨ā§āϟ āĻŸā§āĻ°ā§āϝāĻžāĻ•āĻŋāĻ‚ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡ "āχāωāϜāĻžāϰ ā§§" āĻāϰ āϰ⧋-āϤ⧇ āφāϜāϕ⧇āϰ āĻĄā§‡āĻŸā§‡ ā§§ā§Ļā§ĻāϟāĻŋ āĻĒ⧇āϜāĻ­āĻŋāϜāĻŋāϟ āĻ•āϞāĻžāĻŽ āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇, āφāĻŦāĻžāϰ "āχāωāϜāĻžāϰ ⧍" āĻāϰ āϰ⧋-āϤ⧇ āĻŽāĻžāĻ¤ā§āϰ ⧍āϟāĻŋ āĻ•āϞāĻžāĻŽ āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ Cassandra āĻŦāĻž HBase āĻāϗ⧁āϞ⧋āϕ⧇ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āύāĻŋāϖ⧁āρāϤāĻ­āĻžāĻŦ⧇ āĻāĻŦāĻ‚ āĻ•āĻŽ āĻ¸ā§āĻĒ⧇āϏ⧇ āĻŽā§āϝāĻžāύ⧇āϜ āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤


84. What is a graph database?​

Graph Database āĻšāϞ⧋ āĻāĻŽāύ āĻāĻ• āĻŦāĻŋāĻļ⧇āώ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϝāĻž āĻĄā§‡āϟāĻžāϰ āĻšā§‡āϝāĻŧ⧇āĻ“ āĻĄā§‡āϟāĻžāϰ āϭ⧇āϤāϰ⧇āϰ āϏāĻŽā§āĻĒāĻ°ā§āĻ• (Relationships) āĻāϰ āĻ“āĻĒāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻŦ⧇āĻļāĻŋ āĻœā§‹āϰ āĻĻ⧇āϝāĻŧāĨ¤ āϏāĻžāϧāĻžāϰāĻŖ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϝ⧇āĻ–āĻžāύ⧇ āĻĢāϰ⧇āύ-āĻ•āĻŋ āĻāĻŦāĻ‚ āϜāϝāĻŧ⧇āύ (Join) āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āϏāĻŽā§āĻĒāĻ°ā§āĻ• āĻ–ā§‹āρāĻœā§‡, āĻ—ā§āϰāĻžāĻĢ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏ⧇āĻ–āĻžāύ⧇ āϏāĻŽā§āĻĒāĻ°ā§āĻ•āϗ⧁āϞ⧋āϕ⧇ āĻĢāĻžāĻ°ā§āĻ¸ā§āϟ-āĻ•ā§āϞāĻžāϏ āϏāĻŋāϟāĻŋāĻœā§‡āύ (First-class citizen) āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĢāĻŋāϜāĻŋāĻ•ā§āϝāĻžāϞāĻŋ āϏ⧇āĻ­ āĻ•āϰ⧇ āϰāĻžāϖ⧇āĨ¤

āĻāϟāĻŋ āĻĄā§‡āϟāĻžāϕ⧇ āύ⧋āĻĄ (Nodes - āϝ⧇āĻŽāύ: āĻāĻ•āϜāύ āĻŽāĻžāύ⧁āώ āĻŦāĻž āĻāĻ•āϟāĻŋ āĻĒā§āϰ⧋āĻĄāĻžāĻ•ā§āϟ) āĻāĻŦāĻ‚ āϏ⧇āχ āύ⧋āĻĄāϗ⧁āϞ⧋āϰ āĻŽāĻ§ā§āϝāĻ•āĻžāϰ āϏāĻŽā§āĻĒāĻ°ā§āĻ•āϕ⧇ āĻāϜ (Edges - āϝ⧇āĻŽāύ: "āĻŦāĻ¨ā§āϧ⧁āĻ¤ā§āĻŦ" āĻŦāĻž "āĻ•āĻŋāύ⧇āϛ⧇") āĻšāĻŋāϏ⧇āĻŦ⧇ āϏāĻ‚āϰāĻ•ā§āώāĻŖ āĻ•āϰ⧇āĨ¤

Technical definition: A graph database is a type of NoSQL database that utilizes graph mathematical structures equipped with nodes, edges, and properties to represent and store highly interconnected data. It heavily optimizes relationship traversals (graph hops) without expensive index lookups or table joins.

Examples like Neo4j, Amazon Neptune?​

  • Neo4j: āĻāϟāĻŋ āĻŦāĻ°ā§āϤāĻŽāĻžāύ āĻŦāĻŋāĻļā§āĻŦ⧇āϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϜāύāĻĒā§āϰāĻŋāϝāĻŧ āĻāĻŦāĻ‚ āĻŦāĻšā§āϞ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻ—ā§āϰāĻžāĻĢ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāĨ¤ āĻāϤ⧇ āĻĄā§‡āϟāĻž āϕ⧋āϝāĻŧāĻžāϰāĻŋ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ Cypher āύāĻžāĻŽāĻ• āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻļāĻ•ā§āϤāĻŋāĻļāĻžāϞ⧀ āĻāĻŦāĻ‚ āϏāĻšāĻœā§‡ āĻŦā§‹āĻāĻž āϝāĻžāϝāĻŧ āĻāĻŽāύ āĻāĻ•āϟāĻŋ āĻ˛ā§āϝāĻžāĻ™ā§āĻ—ā§ā§Ÿā§‡āϜ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤
  • Amazon Neptune: āĻāϟāĻŋ AWS āĻāϰ āĻ•ā§āϞāĻžāωāĻĄ āύ⧇āϟāĻŋāĻ­ āĻ—ā§āϰāĻžāĻĢ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāĨ¤ āĻāϟāĻŋ Apache TinkerPop (Gremlin) āĻāĻŦāĻ‚ W3C āĻāϰ RDF/SPARQL āϏāĻŽāĻ°ā§āĻĨāύ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ āĻŽā§‚āϞāϤ āĻāĻ¨ā§āϟāĻžāϰāĻĒā§āϰāĻžāχāϜ āĻ¸ā§āϕ⧇āϞ⧇ āύāϞ⧇āϜ āĻ—ā§āϰāĻžāĻĢ āĻŦāĻž āϰ⧇āĻ•āĻŽā§‡āĻ¨ā§āĻĄā§‡āĻļāύ āχāĻžā§āϜāĻŋāύ āĻŦāĻžāύāĻžāϤ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤

What kind of queries are efficient in graph DBs?​

āĻ—ā§āϰāĻžāĻĢ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏ⧇āχ āϏāĻŦ āϕ⧁āϝāĻŧ⧇āϰāĻŋāϰ āĻ•ā§āώ⧇āĻ¤ā§āϰ⧇ āĻŽā§āϝāĻžāϜāĻŋāϕ⧇āϰ āĻŽāϤ⧋ āĻ•āĻžāϜ āĻ•āϰ⧇, āϝ⧇āĻ–āĻžāύ⧇ āϰāĻŋāϞ⧇āĻļāύāĻžāϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻāĻ•āĻžāϧāĻŋāĻ• āϜāϟāĻŋāϞ JOIN āĻ•āϰāϤ⧇ āĻ—āĻŋāϝāĻŧ⧇ āĻ¸ā§āϞ⧋ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ āĻāϗ⧁āϞ⧋āϕ⧇ Deep Traversal āĻŦāϞāĻž āĻšāϝāĻŧāĨ¤

ā§§. āĻĒā§āϝāĻžāϟāĻžāĻ°ā§āύ āĻŽā§āϝāĻžāϚāĻŋāĻ‚ āĻ“ āϰ⧇āĻ•āĻŽā§‡āĻ¨ā§āĻĄā§‡āĻļāύ (Recommendation Engines):

  • "āϰāĻšāĻŋāĻŽ āϝ⧇ āĻĢā§‹āύāϟāĻŋ āĻ•āĻŋāύ⧇āϛ⧇, āϏ⧇āχ āĻāĻ•āχ āĻĢā§‹āύ āφāϰ āϝāĻžāϰāĻž āĻ•āĻŋāύ⧇āϛ⧇, āϤāĻžāϰāĻž āĻĢā§‹āύ⧇āϰ āϏāĻžāĻĨ⧇ āϕ⧀ āϕ⧀ āĻāĻ•ā§āϏ⧇āϏāϰāĻŋāϜ āĻ•āĻŋāύ⧇āϛ⧇?"
  • (āĻāϟāĻŋ āχ-āĻ•āĻŽāĻžāĻ°ā§āϏ⧇ People who bought this also bought... āĻĢāĻŋāϚāĻžāϰ āϤ⧈āϰāĻŋāϤ⧇ āĻ•āĻžāĻœā§‡ āϞāĻžāϗ⧇)āĨ¤

⧍. āϏ⧋āĻļā§āϝāĻžāϞ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ•āĻŋāĻ‚ (Social Networks):

  • "āφāĻĒāύāĻžāϰ āĻŦāĻ¨ā§āϧ⧁āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϕ⧇ āϕ⧇ āφāĻŦāĻžāϰ āφāĻĒāύāĻžāϰ āφāϰ⧇āĻ• āĻŦāĻ¨ā§āϧ⧁āϰ āϏāĻžāĻĨ⧇ āĻŽāĻŋāωāϚ⧁āϝāĻŧāĻžāϞ āĻĢā§āϰ⧇āĻ¨ā§āĻĄ?" (Friend of a Friend āĻŦāĻž FoF query)āĨ¤
  • LinkedIn āĻŦāĻž Facebook āĻāχ āϧāϰāϪ⧇āϰ āĻ—ā§āϰāĻžāĻĢ āĻŽāĻĄā§‡āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇āχ āĻĢā§āϰ⧇āĻ¨ā§āĻĄ āϏāĻžāĻœā§‡āĻļāύ āĻĻā§‡ā§ŸāĨ¤

ā§Š. āĻĢā§āϰāĻĄ āĻĄāĻŋāĻŸā§‡āĻ•āĻļāύ (Fraud Detection):

  • āĻŦā§āϝāĻžāĻ‚āĻ•āϗ⧁āϞ⧋ āĻ—ā§āϰāĻžāĻĢ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻĻ⧇āϖ⧇ āĻ¯ā§‡â€”āĻāĻ•āϟāĻŋ āĻ•ā§āϰ⧇āĻĄāĻŋāϟ āĻ•āĻžāĻ°ā§āĻĄ, āϝāĻž āĻĨ⧇āϕ⧇ āĻ¸ā§āĻ•ā§āϝāĻžāĻŽ āĻšāϝāĻŧ⧇āϛ⧇, āϏ⧇āϟāĻŋ āĻ…āĻ¨ā§āϝ āϕ⧋āύ āϕ⧋āύ āĻ…ā§āϝāĻžāĻ•āĻžāωāĻ¨ā§āϟ, āφāχāĻĒāĻŋ āĻāĻĄā§āϰ⧇āϏ āĻŦāĻž āĻĢā§‹āύ āύāĻžāĻŽā§āĻŦāĻžāϰ⧇āϰ āϏāĻžāĻĨ⧇ āϏāĻ‚āϝ⧁āĻ•ā§āϤāĨ¤

85. What is CAP theorem?​

CAP Theorem (āϝāĻž Brewer's Theorem āύāĻžāĻŽā§‡ āĻĒāϰāĻŋāϚāĻŋāϤ) āĻšāϞ⧋ āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ (Distributed Database) āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āϰ āĻāĻ•āϟāĻŋ āĻŽā§ŒāϞāĻŋāĻ• āĻāĻŦāĻ‚ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻĨāĻŋāĻ“āϰāĻŋāĻŽāĨ¤

āĻāϟāĻŋ āϏāĻšāϜāĻ­āĻžāĻŦ⧇ āĻŦāϞ⧇ āϝ⧇, āϝāĻ–āύ āĻāĻ•āϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻāĻ•āĻžāϧāĻŋāĻ• āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻŦāĻž āύ⧋āĻĄā§‡ (Nodes) āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āĻĨāĻžāϕ⧇, āϤāĻ–āύ āĻāĻ•āχ āϏāĻžāĻĨ⧇ āύāĻŋāĻšā§‡āϰ āϤāĻŋāύāϟāĻŋ āĻŦ⧈āĻļāĻŋāĻˇā§āĻŸā§āϝ⧇āϰ (Properties) āϏāĻŦāϗ⧁āϞ⧋āϤ⧇ ā§§ā§Ļā§Ļ% āĻ—ā§āϝāĻžāϰāĻžāĻ¨ā§āϟāĻŋ āĻĻ⧇āĻ“ā§ŸāĻž āĻ—āĻžāĻŖāĻŋāϤāĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻ…āϏāĻŽā§āĻ­āĻŦāĨ¤ āϚāĻžāχāϞ⧇āĻ“ āϝ⧇āϕ⧋āύ⧋ āĻĻ⧁āϟāĻŋ āĻŦ⧇āϛ⧇ āύāĻŋāϤ⧇ āĻšāĻŦ⧇āĨ¤

CAP āϤāĻŋāύāϟāĻŋ āĻļāĻŦā§āĻĻ⧇āϰ āϏāĻ‚āĻ•ā§āώāĻŋāĻĒā§āϤ āϰ⧂āĻĒ:

  • C - Consistency (āϧāĻžāϰāĻžāĻŦāĻžāĻšāĻŋāĻ•āϤāĻž/āϏāĻ āĻŋāĻ•āϤāĻž): āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϝ⧇āϕ⧋āύ⧋ āύ⧋āĻĄ āĻŦāĻž āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āχāωāϜāĻžāϰ⧇āϰ āĻ•āϰāĻž āϞ⧇āĻŸā§‡āĻ¸ā§āϟ āφāĻĒāĻĄā§‡āϟāϟāĻŋ āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇āχ āĻĒāĻžāĻ“āϝāĻŧāĻž āϝāĻžāĻŦ⧇āĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž, āϏāĻŦāϗ⧁āϞ⧋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϏāĻŦāϏāĻŽāϝāĻŧ āĻāĻ•āχ āĻĄā§‡āϟāĻž āĻĻ⧇āĻ–āĻžāĻŦ⧇āĨ¤
  • A - Availability (āĻĒā§āϰāĻžāĻĒā§āϝāϤāĻž): āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏāĻŦāϏāĻŽāϝāĻŧ āĻāĻ•ā§āϟāĻŋāĻ­ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤ āχāωāϜāĻžāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āϰāĻŋāϕ⧋āϝāĻŧ⧇āĻ¸ā§āϟ āĻĒāĻžāĻ āĻžāϞ⧇ āϏ⧇ āϏāĻŦāϏāĻŽāϝāĻŧ āĻāĻ•āϟāĻŋ āϰ⧇āϏāĻĒāĻ¨ā§āϏ (Failure āĻŽā§‡āϏ⧇āϜ āύāϝāĻŧ) āĻĒāĻžāĻŦ⧇, āĻĄāĻžāϟāĻž āϞ⧇āĻŸā§‡āĻ¸ā§āϟ āĻšā§‹āĻ• āĻŦāĻž āĻāĻ•āϟ⧁ āĻĒ⧁āϰ⧋āύ⧋ āĻšā§‹āĻ•āĨ¤
  • P - Partition Tolerance (āĻŦāĻŋāĻ­āĻžāϜāύ āϏāĻšāύāĻļā§€āϞāϤāĻž): āĻĻ⧁āϟāĻŋ āύ⧋āĻĄ āĻŦāĻž āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āϏāĻ‚āϝ⧋āĻ— āĻŦāĻŋāĻšā§āĻ›āĻŋāĻ¨ā§āύ (Network Partition āĻŦāĻž Communication drop) āĻšāϝāĻŧ⧇ āϗ⧇āϞ⧇āĻ“ āĻĒ⧁āϰ⧋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āĻ•āĻžāϜ āĻ•āϰāĻž āĻŦāĻ¨ā§āϧ āĻ•āϰāĻŦ⧇ āύāĻžāĨ¤

How do NoSQL databases handle the trade-offs?​

āϝ⧇āĻšā§‡āϤ⧁ āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āϤāĻžāϰ āĻ›āĻŋāρāĻĄāĻŧ⧇ āϝāĻžāĻ“āϝāĻŧāĻž āĻŦāĻž āϰāĻžāωāϟāĻžāϰ āύāĻˇā§āϟ āĻšāĻ“āϝāĻŧāĻž (Partition) āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āϏāĻžāϧāĻžāϰāĻŖ āĻāĻ•āϟāĻŋ āϘāϟāύāĻž, āϤāĻžāχ "P" (Partition Tolerance) āϕ⧇ āĻŦāĻžāĻĻ āĻĻ⧇āϝāĻŧāĻžāϰ āϕ⧋āύ⧋ āϏ⧁āϝ⧋āĻ— āύ⧇āχāĨ¤ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽāϕ⧇ "P" āϰāĻžāĻ–āϤ⧇āχ āĻšāϝāĻŧāĨ¤

āĻāϰāĻĒāϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϕ⧇ āĻŦāĻžāĻ§ā§āϝ āĻšāϝāĻŧ⧇ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύāĻŋāϤ⧇ āĻšāϝāĻŧ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āĻĢ⧇āχāϞ āĻ•āϰāϞ⧇ āϤāĻžāϰāĻž āϕ⧀ āĻ•āϰāĻŦā§‡â€”āϤāĻžāϰāĻž āĻ•āĻŋ Consistency (C) āϧāϰ⧇ āϰāĻžāĻ–āĻŦ⧇ āύāĻžāĻ•āĻŋ Availability (A) āϧāϰ⧇ āϰāĻžāĻ–āĻŦ⧇?

  • āϝāĻĻāĻŋ Consistency (C) āĻŦ⧇āϛ⧇ āύ⧇āϝāĻŧ: āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āϏāĻ‚āϝ⧋āĻ— āĻŦāĻŋāĻšā§āĻ›āĻŋāĻ¨ā§āύ āĻĨāĻžāĻ•āĻž āĻ…āĻŦāĻ¸ā§āĻĨāĻžāϝāĻŧ, āĻĄā§‡āϟāĻžāϰ āĻ…āĻŽāĻŋāϞ āĻā§œāĻžāϤ⧇ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āφāĻĒāĻĄā§‡āϟ āύ⧇āϝāĻŧāĻž āĻŦāĻ¨ā§āϧ āĻ•āϰ⧇ āĻĻ⧇āĻŦ⧇āĨ¤ āχāωāϜāĻžāϰ āĻāϰāϰ āĻŽā§‡āϏ⧇āϜ āĻĒāĻžāĻŦ⧇ (Unavailable)āĨ¤
  • āϝāĻĻāĻŋ Availability (A) āĻŦ⧇āϛ⧇ āύ⧇āϝāĻŧ: āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āϏāĻ‚āϝ⧋āĻ— āĻŦāĻŋāĻšā§āĻ›āĻŋāĻ¨ā§āύ āĻĨāĻžāĻ•āĻž āĻ…āĻŦāĻ¸ā§āĻĨāĻžāϝāĻŧāĻ“ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āϰ⧇āϏāĻĒāĻ¨ā§āϏ āĻ•āϰāĻŦ⧇āĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āϏāĻŽāĻ¸ā§āϝāĻž āĻšāϞ⧋, āχāωāϜāĻžāϰ āĻšāϝāĻŧāϤ⧋ āĻĒ⧁āϰ⧋āύ⧋ āĻĄā§‡āϟāĻž (Inconsistent data) āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

Examples of CP, AP, and CA systems?​

  • CP Systems (Consistency & Partition Tolerance):

    • āωāĻĻāĻžāĻšāϰāĻŖ: MongoDB, HBase, Redis (Cluster)āĨ¤
    • āĻ•āĻžāϜ: āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āĻĒāĻžāĻ°ā§āϟāĻŋāĻļāύ āĻšāϞ⧇, āĻāχ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽāϗ⧁āϞ⧋ āĻ…āĻŽāĻŋāϞ āĻā§œāĻžāύ⧋āϰ āϜāĻ¨ā§āϝ āĻŽāĻžāχāύāϰāĻŋāϟāĻŋ āύ⧋āĻĄāϗ⧁āϞ⧋āϕ⧇ āĻļāĻžāϟāĻĄāĻžāωāύ āĻŦāĻž āϰāĻŋāĻĄ-āĻ…āύāϞāĻŋ āĻŽā§‹āĻĄā§‡ āύāĻŋā§Ÿā§‡ āϝāĻžā§Ÿ, āϝāϤāĻ•ā§āώāĻŖ āύāĻž āφāĻŦāĻžāϰ āϏāĻ āĻŋāĻ• āĻĄā§‡āϟāĻž āϏāĻŋāĻ™ā§āĻ• āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤ āĻ…āĻ°ā§āĻĨāĻžā§Ž āĻāϰāĻž āϭ⧁āϞ āĻĄā§‡āϟāĻž āĻĻ⧇āϝāĻŧāĻžāϰ āĻšā§‡āϝāĻŧ⧇ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽāϕ⧇ Unavailable āϰāĻžāĻ–āĻž āĻļā§āϰ⧇āϝāĻŧ āĻŽāύ⧇ āĻ•āϰ⧇āĨ¤
  • AP Systems (Availability & Partition Tolerance):

    • āωāĻĻāĻžāĻšāϰāĻŖ: Apache Cassandra, CouchDB, DynamoDB (Default)āĨ¤
    • āĻ•āĻžāϜ: āĻāϰāĻž āϏāĻŦāϏāĻŽāϝāĻŧ āϰ⧇āϏāĻĒāĻ¨ā§āϏ āĻ•āϰāĻŦ⧇ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āϝāĻžāχ āϘāϟ⧁āĻ• āύāĻž āϕ⧇āύāĨ¤ āύ⧇āϟāĻ“āϝāĻŧāĻžāĻ°ā§āĻ• āĻŦāĻŋāĻ­āĻžāϜāύ⧇āϰ āϏāĻŽāϝāĻŧ āĻāĻ•āϟāĻŋ āύ⧋āĻĄ āĻšāϝāĻŧāϤ⧋ āĻĒ⧁āϰ⧋āύ⧋ āĻĄā§‡āϟāĻž āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ•āĻžāϜ āĻ•āĻ–āύ⧋ āĻŦāĻ¨ā§āϧ āĻšāĻŦ⧇ āύāĻžāĨ¤ (High Availability)āĨ¤
  • CA Systems (Consistency & Availability):

    • āωāĻĻāĻžāĻšāϰāĻŖ: Traditional RDBMS (MySQL, Oracle) āϝāĻ–āύ āϏāĻŋāĻ™ā§āϗ⧇āϞ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āϰāĻžāύ āĻ•āϰ⧇āĨ¤
    • āĻ•āĻžāϜ: āĻāϰāĻž āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āύāϝāĻŧ, āϤāĻžāχ āĻĒāĻžāĻ°ā§āϟāĻŋāĻļāύ āĻšāĻ“āϝāĻŧāĻžāϰ āĻĒā§āϰāĻļā§āύ āύ⧇āχāĨ¤ āϤāĻŦ⧇ āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰāĻŋāĻ‚ āĻ•āϰāϞ⧇ āĻāϰāĻž āϏāĻžāϧāĻžāϰāĻŖāϤ CP āϤ⧇ āĻĒāϰāĻŋāĻŖāϤ āĻšāϝāĻŧāĨ¤

86. What is BASE property in NoSQL?​

āϰāĻŋāϞ⧇āĻļāύāĻžāϞ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ (RDBMS) āϝ⧇āĻ–āĻžāύ⧇ āĻĄā§‡āϟāĻžāϰ āύāĻŋāϖ⧁āρāϤ āĻ—ā§āϝāĻžāϰāĻžāĻ¨ā§āϟāĻŋāϰ āϜāĻ¨ā§āϝ ACID (Atomicity, Consistency, Isolation, Durability) āĻĒā§āϰāĻĒāĻžāĻ°ā§āϟāĻŋ āĻŽā§‡āύ⧇ āϚāϞ⧇, āĻ…āύ⧇āĻ• āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ NoSQL āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āϏ⧇āĻ–āĻžāύ⧇ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻāĻŦāĻ‚ āĻ¸ā§āϕ⧇āϞāĻŋāĻ‚ āĻāϰ āϏ⧁āĻŦāĻŋāϧāĻžāĻ°ā§āĻĨ⧇ BASE āĻĒā§āϰāĻĒāĻžāĻ°ā§āϟāĻŋ āĻĢāϞ⧋ āĻ•āϰ⧇āĨ¤

BASE āĻŽāĻĄā§‡āϞāϟāĻŋ Strict Consistency (āĻ•āĻ ā§‹āϰ āϏāĻ āĻŋāĻ•āϤāĻž) āĻāϰ āĻ“āĻĒāϰ āĻ›āĻžāĻĄāĻŧ āĻĻāĻŋāϝāĻŧ⧇ Availability (āĻĒā§āϰāĻžāĻĒā§āϝāϤāĻž) āĻāϰ āĻ“āĻĒāϰ āĻŦ⧇āĻļāĻŋ āĻœā§‹āϰ āĻĻ⧇āϝāĻŧāĨ¤

B.A. - Basically Available: āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āϏāĻŦāϏāĻŽāϝāĻŧ āĻāϭ⧇āχāĻ˛ā§āϝāĻžāĻŦāϞ āĻĨāĻžāĻ•āĻŦ⧇āĨ¤ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϝāĻĻāĻŋ āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ āĻŦāĻž āĻ•āϝāĻŧ⧇āĻ•āϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻ•ā§āĻ°ā§āϝāĻžāĻļāĻ“ āĻ•āϰ⧇, āĻĒ⧁āϰ⧋ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āĻĄāĻžāωāύ āĻšāĻŦ⧇ āύāĻžāĨ¤ āχāωāϜāĻžāϰ āϏāĻŦāϏāĻŽāϝāĻŧ āϕ⧋āύ⧋ āύāĻž āϕ⧋āύ⧋ āĻāĻ•āϟāĻŋ āϰ⧇āϏāĻĒāĻ¨ā§āϏ āĻĒāĻžāĻŦ⧇āχāĨ¤

S - Soft State: āϝ⧇āĻšā§‡āϤ⧁ Strict Consistency āύ⧇āχ, āϤāĻžāχ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡āϰ āϏāĻžāĻŽāĻ—ā§āϰāĻŋāĻ• āĻ¸ā§āĻŸā§‡āϟ (State) āĻ¸ā§āĻĨāĻŋāϰ āĻĨāĻžāϕ⧇ āύāĻžāĨ¤ āĻŦāĻžāχāϰ⧇ āĻĨ⧇āϕ⧇ āϕ⧋āύ⧋ āύāϤ⧁āύ āĻĄā§‡āϟāĻž āχāύāĻĒ⧁āϟ āύāĻž āĻĻāĻŋāϞ⧇āĻ“ āĻŦā§āϝāĻžāĻ•āĻ—ā§āϰāĻžāωāĻ¨ā§āĻĄā§‡ āύ⧋āĻĄāϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻĄā§‡āϟāĻž āϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāχāĻœā§‡āĻļāύ⧇āϰ āĻ•āĻžāϜ āϚāĻžāϞāĻžāϤ⧇ āĻĨāĻžāϕ⧇, āϝāĻžāϰ āĻĢāϞ⧇ āϏāĻŽāϝāĻŧ⧇āϰ āϏāĻžāĻĨ⧇ āĻĄā§‡āϟāĻžāϰ āĻ­āĻŋāω āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

E - Eventual Consistency: āĻāϟāĻŋ āĻ—ā§āϝāĻžāϰāĻžāĻ¨ā§āϟāĻŋ āĻĻ⧇āϝāĻŧ āϝ⧇, āϏāĻžāĻŽāϝāĻŧāĻŋāĻ•āĻ­āĻžāĻŦ⧇ āĻĄā§‡āϟāĻžāϝāĻŧ āĻ…āĻŽāĻŋāϞ āĻĨāĻžāĻ•āϞ⧇āĻ“, āĻļ⧇āώ āĻĒāĻ°ā§āϝāĻ¨ā§āϤ (Eventually) āϏāĻŦāϗ⧁āϞ⧋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻĄā§‡āϟāĻž āφāĻĒāĻĄā§‡āϟ āĻšāϝāĻŧ⧇ āϝāĻžāĻŦ⧇ āĻāĻŦāĻ‚ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ•āύāϏāĻŋāĻ¸ā§āĻŸā§‡āĻ¨ā§āϟ āĻšāĻŦ⧇āĨ¤

Compare BASE with ACID?​

FeatureACID Properties (SQL)BASE Properties (NoSQL)
Core PhilosophyData Integrity above all (āϏāĻ āĻŋāĻ•āϤāĻž āϏāĻŦāĻžāϰ āφāϗ⧇)āĨ¤High Availability and Scale (āϏāĻžāĻ°ā§āĻ­āĻŋāϏ āϚāĻžāϞ⧁ āϰāĻžāĻ–āĻž āϏāĻŦāĻžāϰ āφāϗ⧇)āĨ¤
ConsistencyStrong ConsistencyāĨ¤ āĻŸā§āϰāĻžāύāĻœā§‡āĻ•āĻļāύ āĻļ⧇āώ āĻšāĻ“ā§ŸāĻž āĻŽāĻžāĻ¤ā§āϰāχ āϏāĻŦāĻžāχ āύāϤ⧁āύ āĻĄā§‡āϟāĻž āĻĻ⧇āĻ–āĻŦ⧇āĨ¤Eventual ConsistencyāĨ¤ āĻ•āĻŋāϛ⧁ āϏāĻŽāϝāĻŧ āĻĒāϰ āϏāĻŦāĻžāχ āύāϤ⧁āύ āĻĄā§‡āϟāĻž āĻĻ⧇āĻ–āĻŦ⧇āĨ¤
Locking MechanismāĻĄā§‡āϟāĻž āĻāĻĄāĻŋāϟ āĻ•āϰāĻžāϰ āϏāĻŽāϝāĻŧ āĻĒ⧇āϏāĻŋāĻŽāĻŋāĻ¸ā§āϟāĻŋāĻ• āĻŦāĻž āĻ…āĻĒāϟāĻŋāĻŽāĻŋāĻ¸ā§āϟāĻŋāĻ• āϞāĻ• āĻ•āϰ⧇ āϝāĻžāϤ⧇ āĻ…āĻ¨ā§āϝāϰāĻž āĻāĻĄāĻŋāϟ āĻ•āϰāϤ⧇ āύāĻž āĻĒāĻžāϰ⧇āĨ¤āϏāĻžāϧāĻžāϰāĻŖāϤ āϕ⧋āύ⧋ āϞāĻ•āĻŋāĻ‚ āĻĨāĻžāϕ⧇ āύāĻž (Optimistic / Conflict resolution)āĨ¤
Primary FocusāĻĢāĻŋāĻ¨ā§āϝāĻžāĻ¨ā§āϏāĻŋāϝāĻŧāĻžāϞ āĻŦāĻž āĻŦā§āϝāĻžāĻ‚āĻ•āĻŋāĻ‚ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ, āϝ⧇āĻ–āĻžāύ⧇ ā§§ āϟāĻžāĻ•āĻžāϰ āĻšāĻŋāϏāĻžāĻŦ⧇āĻ“ āϭ⧁āϞ āĻšāĻ“āϝāĻŧāĻž āϝāĻžāĻŦ⧇ āύāĻžāĨ¤āϏ⧋āĻļā§āϝāĻžāϞ āĻŽāĻŋāĻĄāĻŋ⧟āĻž, āĻ•ā§āϝāĻžāĻļāĻŋāĻ‚, āϞāĻ—āĻŋāĻ‚, āϝ⧇āĻ–āĻžāύ⧇ ā§§-⧍ āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āϞ⧇āĻŸā§‡ āĻĄā§‡āϟāĻž āĻĻ⧇āĻ–āĻžāϞ⧇āĻ“ āϏāĻŽāĻ¸ā§āϝāĻž āύ⧇āχāĨ¤

What is "basically available"?​

Basically Available āĻŽāĻžāύ⧇ āĻšāϞ⧋ āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽāϟāĻŋ āφāĻ‚āĻļāĻŋāĻ• āĻĢ⧇āχāϞāĻŋāϝāĻŧāϰ⧇āϰ āϏāĻŽāϝāĻŧāĻ“ (Partial Failures) āĻ•āĻžāϜ āϚāĻžāϞāĻŋāϝāĻŧ⧇ āϝāĻžāĻ“āϝāĻŧāĻžāϰ āĻ—ā§āϝāĻžāϰāĻžāĻ¨ā§āϟāĻŋ āĻĻ⧇āϝāĻŧāĨ¤

āϧāϰ⧁āύ, āĻāĻ•āϟāĻŋ āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇ ā§ĢāϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āύ⧋āĻĄ āφāϛ⧇āĨ¤ āφāĻĒāύāĻŋ āĻāĻ•āϟāĻŋ āĻĄā§‡āϟāĻž āϖ⧁āρāϜāϛ⧇āύ āϝāĻž ā§Š āύāĻŽā§āĻŦāϰ āύ⧋āĻĄā§‡ āφāϛ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ ā§Š āύāĻŽā§āĻŦāϰ āύ⧋āĻĄāϟāĻŋ āĻšāĻ āĻžā§Ž āĻĄāĻžāωāύ āĻšāϝāĻŧ⧇ āϗ⧇āϞāĨ¤ āĻ āĻ…āĻŦāĻ¸ā§āĻĨāĻžāϝāĻŧ "Basically Available" āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āφāĻĒāύāĻžāϕ⧇ āĻĒ⧁āϰ⧋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĄāĻžāωāύ āύāĻž āĻĻ⧇āĻ–āĻŋāϝāĻŧ⧇, āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ āύ⧋āĻĄ āĻĨ⧇āϕ⧇ āĻ•ā§āϝāĻžāĻļ āĻ•āϰāĻž āĻŦāĻž āϰ⧇āĻĒā§āϞāĻŋāĻ•āĻž (Replica) āĻ•āϰāĻž āĻĄā§‡āϟāĻž āĻĻ⧇āĻ–āĻžāύ⧋āϰ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰāĻŦ⧇āĨ¤ āĻāϟāĻŋ "ā§§ā§Ļā§Ļ% āĻ—ā§āϝāĻžāϰāĻžāĻ¨ā§āϟāĻŋāϝ⧁āĻ•ā§āϤ" āύāϝāĻŧ, āϤāĻŦ⧇ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽāϟāĻŋ āĻ•āĻžāϜ āĻ•āϰāĻžāϰ āϏāĻ°ā§āĻŦā§‹āĻšā§āϚ āĻšā§‡āĻˇā§āϟāĻž āĻ•āϰ⧇āĨ¤


87. What is eventual consistency?​

Eventual Consistency āĻšāϞ⧋ āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻŋāĻ‚ āĻāϰ āĻāĻ•āϟāĻŋ āĻĄā§‡āϟāĻž āĻ•āύāϏāĻŋāĻ¸ā§āĻŸā§‡āĻ¨ā§āϏāĻŋ āĻŽāĻĄā§‡āϞāĨ¤ āĻāϟāĻŋ āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰ⧇ āϝ⧇ āϝāĻĻāĻŋ āϕ⧋āύ⧋ āĻĄā§‡āϟāĻž āφāχāĻŸā§‡āĻŽā§‡ āύāϤ⧁āύ āĻ•āϰ⧇ āϕ⧋āύ⧋ āφāĻĒāĻĄā§‡āϟ āύāĻž āφāϏ⧇, āϤāĻŦ⧇ "āĻšā§‚āĻĄāĻŧāĻžāĻ¨ā§āϤ āĻĒāĻ°ā§āϝāĻžāϝāĻŧ⧇" (Eventually) āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āϏāĻŦāϗ⧁āϞ⧋ āĻ•āĻĒāĻŋāϤ⧇ (Nodes) āĻāχ āĻāĻ•āχ āĻĄā§‡āϟāĻž āφāĻĒāĻĄā§‡āϟ āĻšā§Ÿā§‡ āϝāĻžāĻŦ⧇ āĻāĻŦāĻ‚ āϏāĻŦ āύ⧋āĻĄ āĻ…āĻ­āĻŋāĻ¨ā§āύ āĻĄā§‡āϟāĻž āĻĒā§āϰāĻĻāĻžāύ āĻ•āϰāĻŦ⧇āĨ¤

āϏāĻšāϜ āĻ•āĻĨāĻžāϝāĻŧ, āφāĻĒāύāĻŋ āϝāĻ–āύ āφāĻĒāύāĻžāϰ āĻĒā§āϰ⧋āĻĢāĻžāχāϞ⧇āϰ āĻ›āĻŦāĻŋ āφāĻĒāĻĄā§‡āϟ āĻ•āϰ⧇ āϏ⧇āĻ­ āĻ•āϰ⧇āύ, āϏ⧇āχ āĻĄā§‡āϟāĻž āĻĒā§āϰāĻĨāĻŽā§‡ āĻšāϝāĻŧāϤ⧋ āϏāĻŋāĻ™ā§āĻ—āĻžāĻĒ⧁āϰ⧇āϰ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āύ⧋āĻĄā§‡ āφāĻĒāĻĄā§‡āϟ āĻšāϞ⧋āĨ¤ āĻ āĻŋāĻ• āĻ“āχ āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡āχ āϝāĻĻāĻŋ āϕ⧇āω āφāĻŽā§‡āϰāĻŋāĻ•āĻžāϰ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻĨ⧇āϕ⧇ āφāĻĒāύāĻžāϰ āĻ›āĻŦāĻŋ āĻĻ⧇āϖ⧇, āϏ⧇ āĻšāϝāĻŧāϤ⧋ āφāϗ⧇āϰ āĻ›āĻŦāĻŋāϟāĻŋāχ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāĻŦ⧇āĨ¤ āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻŦā§āϝāĻžāĻ•āĻ—ā§āϰāĻžāωāĻ¨ā§āĻĄā§‡ āϖ⧁āĻŦ āĻĻā§āϰ⧁āϤ āϏāĻŋāĻ™ā§āĻ—āĻžāĻĒ⧁āϰ⧇āϰ āĻĄā§‡āϟāĻž āφāĻŽā§‡āϰāĻŋāĻ•āĻžāϰ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻĒāĻžāĻ āĻŋāϝāĻŧ⧇ āĻĻ⧇āĻŦ⧇āĨ¤ āĻ•āĻŋāϛ⧁ āϏāĻŽāϝāĻŧ āĻĒāϰ āφāĻŽā§‡āϰāĻŋāĻ•āĻžāϰ āύ⧋āĻĄāϟāĻŋāĻ“ āφāĻĒāĻĄā§‡āϟ āĻšāϝāĻŧ⧇ āϝāĻžāĻŦ⧇āĨ¤ āĻāχ āϏāĻžāĻŽāϝāĻŧāĻŋāĻ• āĻ…āĻŽāĻŋāϞ (Delay) āĻŽā§‡āύ⧇ āύ⧇āϝāĻŧāĻžāϟāĻžāχ āĻšāϞ⧋ Eventual ConsistencyāĨ¤

Which NoSQL databases use this model?​

āĻ…āύ⧇āĻ• āĻŦāĻŋāĻ–ā§āϝāĻžāϤ NoSQL āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻāχ āĻŽāĻĄā§‡āϞ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āĻ•āĻžāϰāĻŖ āĻāϟāĻŋ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻ…āύ⧇āĻ• āĻŦāĻžāĻĄāĻŧāĻŋāϝāĻŧ⧇ āĻĻ⧇āϝāĻŧ:

  • Apache Cassandra: (āĻāϟāĻŋ AP āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ, Eventual Consistency āĻāϰ āĻāĻ•āϟāĻŋ āĻĻāĻžāϰ⧁āĻŖ āωāĻĻāĻžāĻšāϰāĻŖ)āĨ¤
  • Amazon DynamoDB: (āĻāϟāĻŋ āĻĄāĻŋāĻĢāĻ˛ā§āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ Eventual Consistency āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇, āϤāĻŦ⧇ āϚāĻžāχāϞ⧇ Strong Consistency āĻāύ⧇āĻŦāϞ āĻ•āϰāĻž āϝāĻžāϝāĻŧ)āĨ¤
  • CouchDB
  • Riak

How long does "eventually" take?​

"Eventually" āĻšāϤ⧇ āĻ āĻŋāĻ• āĻ•āϤāĻ•ā§āώāĻŖ āϞāĻžāĻ—āĻŦ⧇ āϤāĻžāϰ āϕ⧋āύ⧋ āĻĢāĻŋāĻ•ā§āϏāĻĄ āϟāĻžāχāĻŽāĻĢā§āϰ⧇āĻŽ āύ⧇āχāĨ¤ āĻāϟāĻŋ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖāĻ­āĻžāĻŦ⧇ āύāĻŋāĻšā§‡āϰ āĻŦāĻŋāώāϝāĻŧāϗ⧁āϞ⧋āϰ āĻ“āĻĒāϰ āύāĻŋāĻ°ā§āĻ­āϰ āĻ•āϰ⧇:

  1. Network Latency: āϏāĻžāĻ°ā§āĻ­āĻžāϰāϗ⧁āϞ⧋āϰ āĻŽāĻ§ā§āϝāĻ•āĻžāϰ āϭ⧌āĻ—ā§‹āϞāĻŋāĻ• āĻĻā§‚āϰāĻ¤ā§āĻŦ āĻāĻŦāĻ‚ āχāĻ¨ā§āϟāĻžāϰāύ⧇āĻŸā§‡āϰ āĻ¸ā§āĻĒāĻŋāĻĄāĨ¤
  2. Server Load: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻĒā§āϰāϏ⧇āϏāϰ⧇āϰ āĻ•āĻžāĻœā§‡āϰ āϚāĻžāĻĒāĨ¤
  3. Replication Configuration: āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āχāĻžā§āϜāĻŋāύ āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āύāĻĢāĻŋāĻ—āĻžāϰ āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇āĨ¤

āϤāĻŦ⧇ āφāϧ⧁āύāĻŋāĻ• āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡, āϏāĻžāϧāĻžāϰāĻŖāϤ āĻāϟāĻŋ āĻ•āϝāĻŧ⧇āĻ• āĻŽāĻŋāϞāĻŋ-āϏ⧇āϕ⧇āĻ¨ā§āĻĄ (Milli-seconds) āĻāϰ āĻŽāĻ§ā§āϝ⧇āχ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ āĻŦāĻĄāĻŧāĻœā§‹āϰ āĻ•āϝāĻŧ⧇āĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄ āϞāĻžāĻ—āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤

āĻŦāĻžāĻ¸ā§āϤāĻŦ āωāĻĻāĻžāĻšāϰāĻŖ: āχāωāϟāĻŋāωāĻŦ⧇ āϕ⧋āύ⧋ āĻ­āĻŋāĻĄāĻŋāĻ“āϤ⧇ āφāĻĒāύāĻŋ āĻ•āĻŽā§‡āĻ¨ā§āϟ āĻ•āϰāϞ⧇ āφāĻĒāύāĻŋ āϏāĻžāĻĨ⧇ āϏāĻžāĻĨ⧇āχ āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāύ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻ…āĻ¨ā§āϝ āĻĄāĻŋāĻ­āĻžāχāϏ āĻŦāĻž āĻŦā§āϰāĻžāωāϜāĻžāϰ āĻĨ⧇āϕ⧇ āϰāĻŋāĻĢā§āϰ⧇āĻļ āĻ•āϰāϞ⧇ āĻ•āĻŽā§‡āĻ¨ā§āϟāϟāĻŋ āφāϏāϤ⧇ āĻāĻ•āϟ⧁ āϏāĻŽāϝāĻŧ āϞāĻžāϗ⧇āĨ¤ āĻ•āĻžāϰāĻŖ āϏ⧇āχ āĻ•āĻŽā§‡āĻ¨ā§āϟāϟāĻŋ āĻĒ⧃āĻĨāĻŋāĻŦā§€āϰ āϏāĻŦāϗ⧁āϞ⧋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āϏāĻŋāĻ™ā§āĻ•ā§āϰ⧋āύāĻžāχāϜ āĻšāϤ⧇ āĻāĻ•āϟ⧁ "āϏāĻŽāϝāĻŧ" (Eventually) āύāĻŋāĻšā§āϛ⧇āĨ¤


88. What is sharding in NoSQL?​

Sharding āĻšāϞ⧋ āĻĄā§‡āϟāĻžāĻŦ⧇āϏ āĻ¸ā§āϕ⧇āϞāĻŋāĻ‚āϝāĻŧ⧇āϰ āĻāĻ•āϟāĻŋ āφāĻ°ā§āĻ•āĻŋāĻŸā§‡āĻ•āϚāĻžāϰāĻžāϞ āĻ•āύāϏ⧇āĻĒā§āϟ (āϝāĻž Horizontal Partitioning āύāĻžāĻŽā§‡āĻ“ āĻĒāϰāĻŋāϚāĻŋāϤ), āϝ⧇āĻ–āĻžāύ⧇ āĻāĻ•āϟāĻŋ āĻŦāĻŋāĻļāĻžāϞ āĻĄā§‡āϟāĻžāϏ⧇āϟāϕ⧇ āϛ⧋āϟ āϛ⧋āϟ āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āϟ⧁āĻ•āϰ⧋āϤ⧇ āĻ­āĻžāĻ— āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤ āĻāχ āϛ⧋āϟ āϟ⧁āĻ•āϰ⧋āϗ⧁āϞ⧋āϕ⧇ Shard āĻŦāϞāĻž āĻšāϝāĻŧāĨ¤

āĻāϰāĻĒāϰ āĻāχ Shard āϗ⧁āϞ⧋āϕ⧇ āĻāĻ•āϟāĻŋ āϏāĻŋāĻ™ā§āϗ⧇āϞ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āύāĻž āϰ⧇āϖ⧇, āĻāĻ•āĻžāϧāĻŋāĻ• āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ (Nodes) āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āϕ⧇ āĻ›āĻĄāĻŧāĻŋāϝāĻŧ⧇ āĻŦāĻž āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāϟ āĻ•āϰ⧇ āϰāĻžāĻ–āĻž āĻšāϝāĻŧāĨ¤ āĻāϰ āĻĢāϞ⧇ āĻĄā§‡āϟāĻž āĻ¸ā§āĻŸā§‹āϰ āĻ•āϰāĻžāϰ āĻ•ā§āώāĻŽāϤāĻž āĻāĻŦāĻ‚ āϕ⧁āϝāĻŧ⧇āϰāĻŋ āĻĒā§āϰ⧋āϏ⧇āϏāĻŋāĻ‚ āĻ•ā§āώāĻŽāϤāĻž āϰ⧈āĻ–āĻŋāĻ•āĻ­āĻžāĻŦ⧇ (Linearly) āĻŦāĻžāĻĄāĻŧāϤ⧇ āĻĨāĻžāϕ⧇āĨ¤

Technical definition: Sharding is a database architecture pattern related to horizontal partitioning that separates one very large global database into smaller, faster, more easily managed functional units (shards), each residing on a separate physical server instance to distribute load.

How does MongoDB implement auto-sharding?​

MongoDB āϤ⧇ Sharding āĻĒā§āϰāϏ⧇āϏāϟāĻŋ āĻ¸ā§āĻŦāϝāĻŧāĻ‚āĻ•ā§āϰāĻŋāϝāĻŧ āĻŦāĻž Auto-shardingāĨ¤ āĻŽā§āϝāĻžāύ⧁āϝāĻŧāĻžāϞ āĻļāĻžāĻ°ā§āĻĄāĻŋāĻ‚ āĻāϰ āĻŦāĻŋāĻĒāϰ⧀āϤ⧇, āĻĄā§‡āϟāĻžāĻŦ⧇āϏ āύāĻŋāĻœā§‡āχ āĻ āĻŋāĻ• āĻ•āϰ⧇ āϰāĻŋāϝāĻŧ⧇āϞ āϟāĻžāχāĻŽā§‡ āϕ⧋āύ āĻĄā§‡āϟāĻž āϕ⧋āύ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ (Shard) āϝāĻžāĻŦ⧇, āĻāĻŦāĻ‚ āϏ⧇ āύāĻŋāĻœā§‡āχ āĻĄā§‡āϟāĻž āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏ āĻ•āϰ⧇āĨ¤ āĻāϟāĻŋ ā§ŠāϟāĻŋ āĻŽā§‚āϞ āωāĻĒāĻžāĻĻāĻžāύ⧇āϰ āϏāĻžāĻšāĻžāĻ¯ā§āϝ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇:

  1. Shards (Data Nodes): āϝ⧇āĻ–āĻžāύ⧇ āφāϏāϞ āĻĄā§‡āϟāĻžāϗ⧁āϞ⧋ āϟ⧁āĻ•āϰ⧋ āϟ⧁āĻ•āϰ⧋ āĻšāϝāĻŧ⧇ āϜāĻŽāĻž āĻĨāĻžāϕ⧇ (āĻāϗ⧁āϞ⧋ āϏāĻžāϧāĻžāϰāĻŖāϤ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϰ⧇āĻĒā§āϞāĻŋāĻ•āĻž āϏ⧇āϟ āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĨāĻžāϕ⧇)āĨ¤
  2. Config Servers: āĻāϗ⧁āϞ⧋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ "āĻŽā§āϝāĻžāĻĒ" āĻŦāĻž āϰ⧁āϞāϏ āϧāϰ⧇ āϰāĻžāϖ⧇āĨ¤ āϕ⧋āύ āĻĄā§‡āϟāĻž āĻŦāĻž āŽŽāŽ¨ā¯āŽ¤ Shard āĻ āφāϛ⧇, āϤāĻžāϰ āĻĄāĻŋāϰ⧇āĻ•ā§āϟāϰāĻŋ āĻāĻ–āĻžāύ⧇ āĻĨāĻžāϕ⧇āĨ¤
  3. Mongos (Query Router): āĻāϟāĻŋ āĻŸā§āϰāĻžāĻĢāĻŋāĻ• āĻĒ⧁āϞāĻŋāĻļ⧇āϰ āĻŽāϤ⧋ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤ āĻ•ā§āϞāĻžāϝāĻŧ⧇āĻ¨ā§āϟ āĻŦāĻž āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āϏāϰāĻžāϏāϰāĻŋ Shard āĻ āύāĻ• āĻ•āϰ⧇ āύāĻž, āύāĻ• āĻ•āϰ⧇ Mongos āĻāĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇?

  • āĻ•ā§āϞāĻžāϝāĻŧ⧇āĻ¨ā§āϟ āĻāĻ•āϟāĻŋ āϕ⧁āϝāĻŧ⧇āϰāĻŋ (āϝ⧇āĻŽāύ: "āχāωāϜāĻžāϰ āφāχāĻĄāĻŋ ā§Ģ āϖ⧁āρāϜāĻ›āĻŋ") mongos āĻ āĻĒāĻžāĻ āĻžāϝāĻŧāĨ¤
  • mongos āĻ•āύāĻĢāĻŋāĻ— āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻ•āĻžāϛ⧇ āĻŽā§āϝāĻžāĻĒ āϜāĻžāύāϤ⧇ āϚāĻžāϝāĻŧ (āφāχāĻĄāĻŋ ā§Ģ āϕ⧋āύ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āφāϛ⧇?)āĨ¤
  • āĻ•āύāĻĢāĻŋāĻ— āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻŦāϞ⧇ āĻĻ⧇āϝāĻŧ "āĻāϟāĻŋ Shard 2 āĻ āφāϛ⧇"āĨ¤
  • mongos āϤāĻ–āύ Shard 2 āĻĨ⧇āϕ⧇ āĻĄāĻžāϟāĻž āĻāύ⧇ āĻ•ā§āϞāĻžāϝāĻŧ⧇āĻ¨ā§āϟāϕ⧇ āĻĢ⧇āϰāϤ āĻĻ⧇āϝāĻŧāĨ¤ āϝāĻĻāĻŋ āϕ⧋āύ⧋ Shard āĻ āĻĄāĻžāϟāĻž āĻ…āϤāĻŋāϰāĻŋāĻ•ā§āϤ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āϤāĻŦ⧇ ë°ąāĻ—ā§āϰāĻžāωāĻ¨ā§āĻĄā§‡ MongoDB āĻāϰ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏāĻžāϰ (Balancer) āĻĄā§‡āϟāĻžāϰ "Chunk" āϗ⧁āϞ⧋ āĻ…āĻ¨ā§āϝ āĻ–āĻžāϞāĻŋ Shard āĻ āĻĒāĻžāĻ āĻŋāϝāĻŧ⧇ āϞ⧋āĻĄ āĻŦā§āϝāĻžāϞ⧇āĻ¨ā§āϏ āĻ•āϰ⧇āĨ¤

What is shard key selection strategy?​

Shard Key āĻšāϞ⧋ āϏ⧇āχ āĻĢāĻŋāĻ˛ā§āĻĄ āĻŦāĻž āĻ•āϞāĻžāĻŽ āϝāĻžāϰ āĻ“āĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āĻ āĻŋāĻ• āĻ•āϰ⧇ āĻĄā§‡āϟāĻžāϕ⧇ āϕ⧀āĻ­āĻžāĻŦ⧇ āϟ⧁āĻ•āϰ⧋ āĻ•āϰāĻž āĻšāĻŦ⧇āĨ¤ āĻāĻ•āϟāĻŋ āϭ⧁āϞ Shard Key āĻĒ⧁āϰ⧋ āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇āϰ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻ§ā§āĻŦāĻ‚āϏ āĻ•āϰ⧇ āĻĻāĻŋāϤ⧇ āĻĒāĻžāϰ⧇ (āϝāĻžāϕ⧇ Hotspotting āĻŦāϞ⧇)āĨ¤ āϏāĻ āĻŋāĻ• Shard Key āĻŦāĻžāĻ›āĻžāχ āĻ•āϰāĻžāϰ āĻŽā§‚āϞāϤ ā§ŠāϟāĻŋ āĻ¸ā§āĻŸā§āĻ°ā§āϝāĻžāĻŸā§‡āϜāĻŋ āφāϛ⧇:

  1. Hashed Sharding: Shard Key āĻāϰ āĻ­ā§āϝāĻžāϞ⧁āϕ⧇ āĻšā§āϝāĻžāĻļ (Hash āĻĢāĻžāĻ‚āĻļāύ) āĻ•āϰ⧇ āϤāĻžāϰāĻĒāϰ āĻĄā§‡āϟāĻž āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāϟ āĻ•āϰāĻž āĻšāϝāĻŧāĨ¤
  • āϏ⧁āĻŦāĻŋāϧāĻž: āĻāϟāĻŋ āĻĄā§‡āϟāĻžāϕ⧇ āϏāĻŦāϗ⧁āϞ⧋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻāĻ•āĻĻāĻŽ āϏāĻŽāĻžāύāĻ­āĻžāĻŦ⧇ āĻ­āĻžāĻ— āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧ (Even distribution)āĨ¤
  • āĻ…āϏ⧁āĻŦāĻŋāϧāĻž: Range query (āϝ⧇āĻŽāύ "ID ā§§ āĻĨ⧇āϕ⧇ ā§§ā§Ļā§Ļ āĻĄāĻžāϟāĻž āĻĻāĻžāĻ“") āϖ⧁āĻŦ āĻ¸ā§āϞ⧋ āĻšāϝāĻŧ, āĻ•āĻžāϰāĻŖ āĻĄāĻžāϟāĻž āϏāĻŦ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻ›āĻĄāĻŧāĻžāύ⧋ āĻĨāĻžāϕ⧇āĨ¤
  1. Ranged Sharding: Shard Key āĻāϰ āĻ­ā§āϝāĻžāϞ⧁āϰ āϰ⧇āĻžā§āϜ āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āĻĄā§‡āϟāĻž āĻ­āĻžāĻ— āĻšāϝāĻŧāĨ¤ (āϝ⧇āĻŽāύ A-M āύāĻžāĻŽā§‡āϰ āĻŽāĻžāύ⧁āώ Shard 1 āĻ, N-Z āύāĻžāĻŽā§‡āϰ āĻŽāĻžāύ⧁āώ Shard 2 āĻ)āĨ¤
  • āϏ⧁āĻŦāĻŋāϧāĻž: Range query āĻāϰ āϜāĻ¨ā§āϝ āĻāϟāĻŋ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻĢāĻžāĻ¸ā§āϟāĨ¤
  • āĻ…āϏ⧁āĻŦāĻŋāϧāĻž: āĻĄā§‡āϟāĻž āφāύ-āχāϭ⧇āύāϞāĻŋ āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāϟ āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ (āϧāϰāĻŋ A-M āύāĻžāĻŽā§‡āϰ āĻŽāĻžāύ⧁āώ āĻŦ⧇āĻļāĻŋ, āϤāĻ–āύ Shard 1 āĻ āĻ“āĻ­āĻžāϰāϞ⧋āĻĄ āĻšāϝāĻŧ⧇ āϝāĻžāĻŦ⧇)āĨ¤
  1. Choosing the Right Key (āĻŽā§ŒāϞāĻŋāĻ• āύāĻŋāϝāĻŧāĻŽ): Shard key āĻāĻŽāύ āĻšāĻ“āϝāĻŧāĻž āωāϚāĻŋāϤ āϝāĻžāϰ āĻĒā§āϰāϚ⧁āϰ āφāϞāĻžāĻĻāĻž āφāϞāĻžāĻĻāĻž āĻ­ā§āϝāĻžāϞ⧁ āφāϛ⧇ (High cardinality) āĻāĻŦāĻ‚ āĻĄā§‡āϟāĻžāĻŦ⧇āϏ⧇āϰ āĻŦ⧇āĻļāĻŋāϰāĻ­āĻžāĻ— āϕ⧁āϝāĻŧ⧇āϰāĻŋāϤ⧇āχ āĻĢāĻŋāĻ˛ā§āϟāĻžāϰ āĻšāĻŋāϏ⧇āĻŦ⧇ āϐ Key āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤

89. What is replication in NoSQL?​

Replication āĻšāϞ⧋ āĻĄā§‡āϟāĻžāĻŦ⧇āϏ⧇āϰ āĻāĻ•āχ āĻĄā§‡āϟāĻžāϕ⧇ āĻšā§āĻŦāĻšā§ āĻāĻ•āĻžāϧāĻŋāĻ• āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ (Nodes) āĻ•āĻĒāĻŋ (Copy) āĻŦāĻž āĻ•ā§āϞ⧋āύ āĻ•āϰ⧇ āϰāĻžāĻ–āĻžāϰ āĻāĻ•āϟāĻŋ āĻĒā§āϰāĻ•ā§āϰāĻŋāϝāĻŧāĻžāĨ¤

Sharding āĻāϰ āĻŽā§‚āϞ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻšāϞ⧋ "āĻ¸ā§āϕ⧇āϞāĻŋāĻ‚ āĻŦāĻž āĻ•ā§āϝāĻžāĻĒāĻžāϏāĻŋāϟāĻŋ āĻŦāĻžāĻĄāĻŧāĻžāύ⧋", āĻ…āĻ¨ā§āϝāĻĻāĻŋāϕ⧇ Replication āĻāϰ āĻŽā§‚āϞ āωāĻĻā§āĻĻ⧇āĻļā§āϝ āĻšāϞ⧋ High Availability (āĻĒā§āϰāĻžāĻĒā§āϝāϤāĻž) āĻāĻŦāĻ‚ Fault Tolerance (āĻ•ā§āĻ°ā§āϝāĻžāĻļ āϏāĻžāĻŽāϞāĻžāύ⧋āϰ āĻ•ā§āώāĻŽāϤāĻž) āύāĻŋāĻļā§āϚāĻŋāϤ āĻ•āϰāĻžāĨ¤ āϝāĻĻāĻŋ āϕ⧋āύ⧋ āĻ•āĻžāϰāϪ⧇ āφāĻĒāύāĻžāϰ āĻŽā§‡āχāύ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āĻĒ⧁āĻĄāĻŧ⧇ āϝāĻžāϝāĻŧ āĻŦāĻž āĻšāĻžāĻ°ā§āĻĄāĻĄāĻŋāĻ¸ā§āĻ• āĻ•ā§āĻ°ā§āϝāĻžāĻļ āĻ•āϰ⧇, āϤāĻŦ⧇ āĻ…āĻ¨ā§āϝ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇ āĻĨāĻžāĻ•āĻž āĻ•āĻĒāĻŋ āĻĨ⧇āϕ⧇ āĻŽā§āĻšā§‚āĻ°ā§āϤ⧇āχ āĻĄā§‡āϟāĻž āϰāĻŋāĻ•āĻ­āĻžāϰ āĻŦāĻž āĻāĻ•ā§āϏ⧇āϏ āĻ•āϰāĻž āϏāĻŽā§āĻ­āĻŦ āĻšāϝāĻŧāĨ¤

Difference between master-slave and master-master?​

āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āύ⧋āĻĄ āϗ⧁āϞ⧋āϰ āĻŽāĻ§ā§āϝ⧇ āĻĄā§‡āϟāĻž āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ›āĻĄāĻŧāĻžāĻŦ⧇, āϤāĻžāϰ āĻ“āĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύāϕ⧇ āĻĒā§āϰāϧāĻžāύāϤ āĻĻ⧁āϟāĻŋ āĻ­āĻžāϗ⧇ āĻ­āĻžāĻ— āĻ•āϰāĻž āϝāĻžāϝāĻŧ:

FeatureMaster-Slave (Primary-Secondary)Master-Master (Peer-to-Peer / Multi-Leader)
Write OperationsāĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ āĻāĻ•āϟāĻŋ āĻŽāĻžāĻ¤ā§āϰ āύ⧋āĻĄā§‡ (Master) āϰāĻžāχāϟ (Insert/Update) āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇āϰ āϝ⧇āϕ⧋āύ⧋ āύ⧋āĻĄā§‡ āϰāĻžāχāϟ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤ āϏāĻŦāĻžāχ āĻāĻ•āĻžāϧāĻžāϰ⧇ MasterāĨ¤
Read OperationsSlave āύ⧋āĻĄāϗ⧁āϞ⧋ āĻĨ⧇āϕ⧇ āϏāĻžāϧāĻžāϰāĻŖāϤ āĻļ⧁āϧ⧁ āĻĄā§‡āϟāĻž āϰāĻŋāĻĄ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤ (āϰāĻŋāĻĄ āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ āĻŦāĻžāĻĄāĻŧāĻžāϝāĻŧ)āĨ¤āϝ⧇āϕ⧋āύ⧋ āύ⧋āĻĄ āĻĨ⧇āϕ⧇ āϰāĻŋāĻĄ āĻ“ āϰāĻžāχāϟ āĻĻ⧁āϟāĻŋāχ āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤
Data FlowOne-wayāĨ¤ Master āĻ āĻĄā§‡āϟāĻž āĻĸā§‹āϕ⧇, āϤāĻžāϰāĻĒāϰ āĻŦā§āϝāĻžāĻ•āĻ—ā§āϰāĻžāωāĻ¨ā§āĻĄā§‡ āϤāĻž Slave āϗ⧁āϞ⧋āϤ⧇ āĻ•āĻĒāĻŋ āĻšāϝāĻŧāĨ¤Two-way āĻŦāĻž Multi-wayāĨ¤ āĻĄāĻžāϟāĻž āύ⧋āĻĄāϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻĄā§‡āϟāĻž āϏāĻŋāĻ™ā§āĻ• āĻ•āϰ⧇āĨ¤
Conflict Resolutionāϝ⧇āĻšā§‡āϤ⧁ āĻāĻ•āϜāύāχ āϰāĻžāχāϟ āĻ•āϰ⧇, āϤāĻžāχ āĻ•āύāĻĢā§āϞāĻŋāĻ•ā§āϟ āĻŦāĻž āĻĄā§‡āϟāĻžāϰ āϏāĻžāĻ‚āϘāĻ°ā§āώāĻŋāĻ• āĻ…āĻŦāĻ¸ā§āĻĨāĻž āϤ⧈āϰāĻŋ āĻšāϝāĻŧā§€āĻŦāĻŋāĻ•āĻž āϤ⧈āϰāĻŋ āĻšāϝāĻŧ āύāĻžāĨ¤āĻāĻ•āχ āĻĄā§‡āϟāĻž āϝāĻĻāĻŋ āĻĻ⧁āϜāύ āχāωāϜāĻžāϰ āĻĻ⧁āϟāĻŋ āĻ­āĻŋāĻ¨ā§āύ āύ⧋āĻĄā§‡ āĻāĻ•āχ āϏāĻŽāϝāĻŧ⧇ āφāĻĒāĻĄā§‡āϟ āĻ•āϰ⧇, āĻ•āύāĻĢā§āϞāĻŋāĻ•ā§āϟ āϤ⧈āϰāĻŋ āĻšāϝāĻŧāĨ¤ āϤāĻ–āύ āĻ­āĻžāĻ°ā§āĻļāύ āĻ•āĻ¨ā§āĻŸā§āϰ⧋āϞ āĻŦāĻž āϞāĻžāĻ¸ā§āϟ-āϰāĻžāχāϟ-āωāχāύāϏ (LWW) āϞāϜāĻŋāĻ• āĻĻāĻŋāϝāĻŧ⧇ āĻāĻžāĻŽā§‡āϞāĻž āĻŽā§‡āϟāĻžāϤ⧇ āĻšāϝāĻŧāĨ¤
Best Used ForRead-heavy āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύāĨ¤Write-heavy āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻāĻŦāĻ‚ ā˛—ā§āϞ⧋āĻŦāĻžāϞ āĻĄā§‡āϟāĻž āϏ⧇āĻ¨ā§āϟāĻžāϰ āϏ⧇āϟāφāĻĒāĨ¤
ExamplesMongoDB, MySQL, PostgreSQLApache Cassandra, Amazon DynamoDB, CouchDB

How does MongoDB replica set work?​

MongoDB āϤ⧇ āϰ⧇āĻĒā§āϞāĻŋāϕ⧇āĻļāύ āĻŦā§āϝāĻŦāĻ¸ā§āĻĨāĻžāϟāĻŋāϕ⧇ Replica Set āĻŦāϞāĻž āĻšāϝāĻŧāĨ¤ āĻāϟāĻŋ Master-Slave āφāĻ°ā§āĻ•āĻŋāĻŸā§‡āĻ•āϚāĻžāϰ⧇āϰ āĻāĻ•āϟāĻŋ āωāĻ¨ā§āύāϤ āϰ⧂āĻĒ āϝāĻžāϰ āĻ…āĻŸā§‹āĻŽā§‡āϟāĻŋāĻ• āϰāĻŋāĻ•āĻ­āĻžāϰāĻŋ āĻ•ā§āώāĻŽāϤāĻž āφāϛ⧇āĨ¤

  • āĻāĻ•āϟāĻŋ āŽŸāŽŋāŽĒā¯āŽĒāĻŋāϕ⧇āϞ Replica Set āĻ āĻāĻ•āϟāĻŋ Primary (Master) āύ⧋āĻĄ āĻāĻŦāĻ‚ āĻāĻ•āĻžāϧāĻŋāĻ• Secondary (Slave) āύ⧋āĻĄ āĻĨāĻžāϕ⧇āĨ¤
  • āĻ…ā§āϝāĻžāĻĒā§āϞāĻŋāϕ⧇āĻļāύ⧇āϰ āϏāĻŦ āϰāĻžāχāϟ (Write) āĻ…āĻĒāĻžāϰ⧇āĻļāύ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ Primary āύ⧋āĻĄā§‡āχ āφāϏ⧇āĨ¤
  • Primary āύ⧋āĻĄ āϤāĻžāϰ āĻ•āĻžāϜāϗ⧁āϞ⧋āϰ āĻāĻ•āϟāĻŋ āϰ⧇āĻ•āĻ°ā§āĻĄ āĻŦāĻž āϞāĻ— āϤ⧈āϰāĻŋ āĻ•āϰ⧇, āϝāĻžāϕ⧇ āĻŦāϞāĻž āĻšāϝāĻŧ Oplog (Operations Log)āĨ¤
  • Secondary āύ⧋āĻĄāϗ⧁āϞ⧋ āϏāĻŦāϏāĻŽāϝāĻŧ Primary āĻāϰ Oplog āĻšā§‡āĻ• āĻ•āϰāϤ⧇ āĻĨāĻžāϕ⧇ āĻāĻŦāĻ‚ āύāϤ⧁āύ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύāϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϜāĻžāύāĻŋāϝāĻŧ⧇ āĻĄā§‡āϟāĻž āϏāĻŋāĻ™ā§āĻ• āĻŦāĻž āφāĻĒāĻĄā§‡āϟ āĻ•āϰ⧇ āύ⧇āϝāĻŧāĨ¤
  • Automatic Failover: āϝāĻĻāĻŋ āϕ⧋āύ⧋ āĻ•āĻžāϰāϪ⧇ Primary āύ⧋āĻĄ āĻĄāĻžāωāύ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧ, āϤāĻŦ⧇ āĻŦāĻžāĻ•āĻŋ Secondary āύ⧋āĻĄāϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻ•āϝāĻŧ⧇āĻ• āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡āϰ āĻŽāĻ§ā§āϝ⧇ āĻāĻ•āϟāĻŋ āĻ­ā§‹āϟāĻžāϭ⧁āϟāĻŋāϰ (Automatic Election) āφāϝāĻŧā§‹āϜāύ āĻ•āϰ⧇āĨ¤ āϝ⧇ āύ⧋āĻĄā§‡āϰ āĻ•āĻžāϛ⧇ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āϞ⧇āĻŸā§‡āĻ¸ā§āϟ āĻĄā§‡āϟāĻž āφāϛ⧇, āϏ⧇ āύāϤ⧁āύ Primary āĻšāĻŋāϏ⧇āĻŦ⧇ āύāĻŋāĻ°ā§āĻŦāĻžāϚāĻŋāϤ āĻšāϝāĻŧ āĻāĻŦāĻ‚ āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽ āĻĒ⧁āύāϰāĻžāϝāĻŧ āĻāĻ•ā§āϟāĻŋāĻ­ āĻšāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤

90. What is MapReduce?​

MapReduce āĻšāϞ⧋ āĻŦāĻŋāĻļāĻžāϞ āĻĒāϰāĻŋāĻŽāĻžāĻŖ (Petabytes) āĻĄā§‡āϟāĻž āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻĻā§āϰ⧁āϤ āĻĒā§āϰāϏ⧇āϏ āĻāĻŦāĻ‚ āĻāύāĻžāϞāĻžāχāϏāĻŋāϏ āĻ•āϰāĻžāϰ āϜāĻ¨ā§āϝ āĻāĻ•āϟāĻŋ āĻĒā§āϰ⧋āĻ—ā§āϰāĻžāĻŽāĻŋāĻ‚ āĻŽāĻĄā§‡āϞāĨ¤ āĻāϟāĻŋ āĻļ⧁āϰ⧁āϤ⧇ Google āωāĻĻā§āĻ­āĻžāĻŦāύ āĻ•āϰ⧇āĻ›āĻŋāϞ āĻāĻŦāĻ‚ āĻĒāϰāĻŦāĻ°ā§āϤ⧀āϤ⧇ āĻšāĻžāĻĄā§āĻĒ (Hadoop) āĻ“ āĻ…āĻ¨ā§āϝāĻžāĻ¨ā§āϝ NoSQL āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϗ⧁āϞ⧋āϤ⧇ āĻŦā§āϝāĻžāĻĒāĻ•āĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧāĨ¤

āĻāϟāĻŋ āĻĄāĻŋāĻ¸ā§āĻŸā§āϰāĻŋāĻŦāĻŋāωāĻŸā§‡āĻĄ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻĄā§‡āϟāĻžāϕ⧇ āĻĒā§āϰāϏ⧇āϏ āĻ•āϰāϤ⧇ āĻŽā§‚āϞāϤ āĻĻ⧁āϟāĻŋ āϧāĻžāĻĒ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇:

  1. Map Phase (āĻŽā§āϝāĻžāĻĒāĻŋāĻ‚): āĻŦāĻŋāĻļāĻžāϞ āĻĄā§‡āϟāĻžāϏ⧇āϟāϕ⧇ āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻ­āĻžāĻ— āĻ•āϰ⧇ āĻĻ⧇āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ āϏāĻžāĻ°ā§āĻ­āĻžāϰ āϤāĻžāϰ āĻ­āĻžāϗ⧇āϰ āĻĄā§‡āϟāĻž āĻĨ⧇āϕ⧇ āĻĒā§āϰāϝāĻŧā§‹āϜāύ⧀āϝāĻŧ āϜāĻŋāύāĻŋāϏ āĻŦ⧇āϰ āĻ•āϰ⧇ (Filter) āĻāĻŦāĻ‚ āϤāĻžāϕ⧇ āĻ•āĻŋ-āĻ­ā§āϝāĻžāϞ⧁ (Key-Value) āĻĒ⧇āϝāĻŧāĻžāϰ⧇ āϰ⧂āĻĒāĻžāĻ¨ā§āϤāϰ āĻ•āϰ⧇āĨ¤
  2. Reduce Phase (āϰāĻŋāĻĄāĻŋāωāϏāĻŋāĻ‚): Map āĻĢ⧇āϜ āĻĨ⧇āϕ⧇ āĻĒā§āϰāĻžāĻĒā§āϤ āĻ•āĻŋ-āĻ­ā§āϝāĻžāϞ⧁ āĻĄā§‡āϟāĻžāϗ⧁āϞ⧋āϕ⧇ āĻāĻ•āϏāĻžāĻĨ⧇ āϝ⧋āĻ— āĻ•āϰ⧇, āϗ⧁āĻŖ āĻ•āϰ⧇ āĻŦāĻž āĻāĻ—ā§āϰāĻŋāϗ⧇āϟ (āĻ—ā§āϰ⧁āĻĒāĻŋāĻ‚) āĻ•āϰ⧇ āĻāĻ•āϟāĻŋ āĻšā§‚āĻĄāĻŧāĻžāĻ¨ā§āϤ āϏāĻžāĻŽāĻžāϰāĻŋ āĻĢāϞāĻžāĻĢāϞ āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĨ¤

āωāĻĻāĻžāĻšāϰāĻŖ: āϧāϰ⧁āύ āφāĻĒāύāĻŋ āϞāĻ•ā§āώ āϞāĻ•ā§āώ āφāĻ°ā§āϟāĻŋāϕ⧇āϞ⧇ āϕ⧋āύ āĻļāĻŦā§āĻĻ āĻ•āϤāĻŦāĻžāϰ āφāϛ⧇ āϤāĻž āϗ⧁āύāϤ⧇ āϚāĻžāύāĨ¤

  • Map āĻĢāĻžāĻ‚āĻļāύ āĻĒā§āϰāϤāĻŋāϟāĻŋ āφāĻ°ā§āϟāĻŋāϕ⧇āϞ⧇āϰ āĻļāĻŦā§āĻĻāϗ⧁āϞ⧋āϕ⧇ āϞāĻžāχāύ āĻŦāĻžāχ āϞāĻžāχāύ ("āĻļāĻŦā§āĻĻ", 1) āĻšāĻŋāϏ⧇āĻŦ⧇ āφāϞāĻžāĻĻāĻž āĻ•āϰāĻŦ⧇āĨ¤
  • Reduce āĻĢāĻžāĻ‚āĻļāύ āϏ⧇āχ āĻ¸ā§āĻĒ⧇āϏāĻŋāĻĢāĻŋāĻ• āĻļāĻŦā§āĻĻāϗ⧁āϞ⧋āϰ āϏāĻŦāĻ—āϞ⧋ 1 āϕ⧇ āϝ⧋āĻ— āĻ•āϰ⧇ āĻŸā§‹āϟāĻžāϞ āύāĻžāĻŽā§āĻŦāĻžāϰ āφāωāϟāĻĒ⧁āϟ āĻĻ⧇āĻŦ⧇āĨ¤

When would you prefer aggregation pipeline instead?​

MongoDB-āϤ⧇ āĻāĻ•āϏāĻŽāϝāĻŧ MapReduce āĻŦ⧇āĻļ āϜāύāĻĒā§āϰāĻŋāϝāĻŧ āĻĨāĻžāĻ•āϞ⧇āĻ“, āĻŦāĻ°ā§āϤāĻŽāĻžāύ⧇ Aggregation Pipeline (āĻāĻ—ā§āϰāĻŋāϗ⧇āĻļāύ āĻĒāĻžāχāĻĒāϞāĻžāχāύ) āϏāĻŦāϚāĻžāχāϤ⧇ āĻŦ⧇āĻļāĻŋ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāϝāĻŧ āĻāĻŦāĻ‚ MapReduce āϕ⧇ āĻĒāϰāĻŋāĻšāĻžāϰ āĻ•āϰāĻžāϰ āĻĒāϰāĻžāĻŽāĻ°ā§āĻļ āĻĻ⧇āϝāĻŧāĻž āĻšāϝāĻŧāĨ¤ āĻāϰ āĻ•āĻžāϰāĻŖāϗ⧁āϞ⧋ āĻšāϞ⧋:

  • āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ (Efficiency): Aggregation pipeline āϏāϰāĻžāϏāϰāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ āχāĻžā§āϜāĻŋāύ⧇ C++ āĻĻāĻŋāϝāĻŧ⧇ āϞ⧇āĻ–āĻž, āϤāĻžāχ āĻāϟāĻŋ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻĢāĻžāĻ¸ā§āϟāĨ¤ āĻ…āĻ¨ā§āϝāĻĻāĻŋāϕ⧇ MapReduce āϏāĻžāϧāĻžāϰāĻŖāϤ JavaScript āχāĻ¨ā§āϟāĻžāϰāĻĒā§āϰ⧇āϟāĻžāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧋, āϝāĻž āĻĒāĻžāϰāĻĢāϰāĻŽā§āϝāĻžāĻ¨ā§āϏ⧇ āĻ…āύ⧇āĻ• āĻ¸ā§āϞ⧋āĨ¤
  • āĻŦā§āϝāĻŦāĻšāĻžāϰāϝ⧋āĻ—ā§āϝāϤāĻž (Usability/Simplicity): Aggregation pipeline āĻ $match, $group, $project, $sort āύāĻžāĻŽāĻ• āĻ¸ā§āĻŸā§‡āϜāϗ⧁āϞ⧋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āϞ⧇āĻ—ā§‹āϰ (Lego) āĻŦā§āϞāϕ⧇āϰ āĻŽāϤ⧋ āĻāĻ•āϟāĻŋāϰ āĻĒāϰ āĻāĻ•āϟāĻŋ āĻĄā§‡āϟāĻž āĻĒā§āϰāϏ⧇āϏāĻŋāĻ‚ āĻĒāĻžāχāĻĒāϞāĻžāχāύ āϤ⧈āϰāĻŋ āĻ•āϰāĻž āϝāĻžāϝāĻŧ, āϝāĻž āĻŦā§‹āĻāĻž āĻāĻŦāĻ‚ āĻĄāĻŋāĻŦāĻžāĻ— āĻ•āϰāĻž āϕ⧋āĻĄāĻŋāĻ‚āϝāĻŧ⧇āϰ āϤ⧁āϞāύāĻžāϝāĻŧ āĻ…āύ⧇āĻ• āϏāĻšāϜāĨ¤
  • āĻ•āĻ–āύ āĻĒā§āϰ⧇āĻĢāĻžāϰ āĻ•āϰāĻŦ⧇āύ? āϝāĻ–āύ āφāĻĒāύāĻžāϕ⧇ āϖ⧁āĻŦ āĻ¸ā§āĻŸā§āϰ⧇āϟ-āĻĢāϰāĻ“āϝāĻŧāĻžāĻ°ā§āĻĄ āĻĢāĻŋāĻ˛ā§āϟāĻžāϰāĻŋāĻ‚, āĻ—ā§āϰ⧁āĻĒāĻŋāĻ‚ āĻŦāĻž āĻĄā§‡āϟāĻž āĻŽā§āϝāĻžāύāĻŋāĻĒ⧁āϞ⧇āĻļāύ āĻ•āϰāϤ⧇ āĻšāĻŦ⧇, āϤāĻ–āύ Aggregation Pipeline āχ āĻšāϞ⧋ āĻŦ⧇āĻ¸ā§āϟ āϚāϝāĻŧ⧇āϏāĨ¤

Is MapReduce still relevant today?​

NoSQL āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ (āϝ⧇āĻŽāύ MongoDB) āύāĻŋāϜāĻ¸ā§āĻŦ āχāϕ⧋āϏāĻŋāĻ¸ā§āĻŸā§‡āĻŽā§‡ MapReduce āĻāϰ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻāĻ–āύ āĻĒā§āϰāĻžāϝāĻŧ āύ⧇āχ āĻŦāϞāϞ⧇āχ āϚāϞ⧇ (MongoDB 5.0 āĻ āĻāϟāĻŋ āĻĄā§‡āĻĒā§āϰāĻŋāϕ⧇āϟ āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇)āĨ¤ āφāϧ⧁āύāĻŋāĻ• āĻĄāĻžāϟāĻžāĻŦ⧇āϏāϗ⧁āϞ⧋āϰ āύāĻŋāϜāĻ¸ā§āĻŦ āĻļāĻ•ā§āϤāĻŋāĻļāĻžāϞ⧀ āχāĻžā§āϜāĻŋāύ āϏ⧇āχ āϜāĻžāϝāĻŧāĻ—āĻž āĻĻāĻ–āϞ āĻ•āϰ⧇ āύāĻŋāϝāĻŧ⧇āϛ⧇āĨ¤

āϤāĻŦ⧇, āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇āϰ āĻŦāĻžāχāϰ⧇ āĻŦāĻŋāĻ—-āĻĄā§‡āϟāĻž āĻāύāĻ­āĻžāϝāĻŧāϰāύāĻŽā§‡āĻ¨ā§āĻŸā§‡ (Big Data Ecosystem) āĻāϰ āĻ•āύāϏ⧇āĻĒā§āϟ āφāϜāĻ“ āĻ…āĻ¤ā§āϝāĻ¨ā§āϤ āĻĒā§āϰāĻžāϏāĻ™ā§āĻ—āĻŋāĻ•āĨ¤

  • Apache HadoopFramework (HDFS) āĻŦāĻž āĻ•ā§āϞāĻžāωāĻĄ āĻ•āĻŽā§āĻĒāĻŋāωāϟāĻŋāĻ‚āϝāĻŧ⧇, āϝ⧇āĻ–āĻžāύ⧇ PetaBytes āĻ¸ā§āϕ⧇āϞ⧇ āĻĄā§‡āϟāĻž āĻāĻ•āϟāĻŋ āĻĄāĻžāϟāĻžāĻŦ⧇āϏ⧇ āύāĻž āĻĨ⧇āϕ⧇ āĻĢā§āĻ˛ā§āϝāĻžāϟ āĻĢāĻžāχāϞ āĻŦāĻž āĻ•ā§āϞāĻžāĻ¸ā§āϟāĻžāϰ⧇ āĻ›āĻĄāĻŧāĻžāύ⧋ āĻĨāĻžāϕ⧇āĨ¤
  • āϝ⧇āĻ–āĻžāύ⧇ āĻ¸ā§āĻŸā§āϝāĻžāĻ¨ā§āĻĄāĻžāĻ°ā§āĻĄ āĻ—ā§āϰ⧁āĻĒāĻŋāĻ‚āϝāĻŧ⧇āϰ āĻŦāĻžāχāϰ⧇ āĻ•āĻžāĻ¸ā§āϟāĻŽ āĻŽā§‡āĻļāĻŋāύ āϞāĻžāĻ°ā§āύāĻŋāĻ‚ āϞāϜāĻŋāĻ• (Custom logic/algorithms) āĻĒā§āϰāϝāĻŧā§‹āĻ— āĻ•āϰāĻžāϰ āĻĒā§āϰāϝāĻŧā§‹āϜāύ āĻšāϝāĻŧ, āϏ⧇āĻ–āĻžāύ⧇ MapReduce-āĻāϰ āĻ•āύāϏ⧇āĻĒā§āϟ āĻŦāĻž āĻāϰ āωāĻ¤ā§āϤāϰāϏ⧂āϰāĻŋ Apache Spark āĻŦā§āϝāĻžāĻĒāĻ•āĻ­āĻžāĻŦ⧇ āĻŦā§āϝāĻŦāĻšā§ƒāϤ āĻšāĻšā§āϛ⧇āĨ¤