Why database choice affects architecture in Deno - Quick Recap

Recall & Review

beginner

Why does the choice of database impact the overall software architecture?

The database defines how data is stored, accessed, and managed. This affects how the application is structured, how components communicate, and how data flows through the system.

beginner

What is a key difference between SQL and NoSQL databases that affects architecture?

SQL databases use structured tables and fixed schemas, which require strict data models. NoSQL databases are more flexible with schemas, allowing dynamic data structures. This influences how data models and queries are designed in the app.

intermediate

How can database scalability influence application design?

If a database scales horizontally (adding more servers), the app might need to handle data partitioning and eventual consistency. Vertical scaling (bigger server) may simplify design but limit growth. Architecture must match the scaling approach.

intermediate

What role does transaction support in a database play in architecture?

Databases with strong transaction support ensure data integrity with multiple operations. This allows simpler app logic for consistency. Without it, the app must handle conflicts and data errors, complicating architecture.

intermediate

How does latency and performance of a database affect system architecture?

Slow database responses require caching layers or asynchronous processing in the app. Fast databases allow simpler synchronous calls. The choice affects how components interact and how user experience is designed.

Which database type usually requires a fixed schema in the application design?

A SQL databases

B NoSQL databases

C In-memory databases

D File-based databases

SQL databases use structured tables with fixed schemas, so the app must follow that structure.

What architectural challenge arises when using a NoSQL database with eventual consistency?

A Managing ACID transactions

B Designing fixed table schemas

C Handling data conflicts and stale reads

D Implementing complex joins

Eventual consistency means data may not be immediately updated everywhere, so the app must handle conflicts and stale data.

How does horizontal scaling of a database affect application architecture?

A Requires data partitioning and distributed logic

B Simplifies data access with a single server

C Eliminates the need for caching

D Removes the need for backups

Horizontal scaling means spreading data across servers, so the app must manage partitions and distributed data.

Why might an application add a caching layer when using a slow database?

A To enforce strict schemas

B To reduce latency and improve response times

C To increase database storage capacity

D To simplify database backups

Caching stores frequent data temporarily to avoid slow database calls, improving speed.

What does strong transaction support in a database allow the application to do?

A Avoid writing any error handling code

B Store unstructured data easily

C Scale horizontally without changes

D Ensure multiple operations succeed or fail together

Transactions guarantee that a group of operations are atomic, keeping data consistent.

Explain how choosing between SQL and NoSQL databases can change your application's architecture.

Think about how structured your data is and how that affects your app design.

Describe how database performance and scalability influence the design of your software system.

Consider what happens when your database gets slow or needs to grow.

Practice

1. Why does the choice of database affect the architecture of a Deno application?

easy

A. Because Deno only supports one type of database

B. Because all databases use the same query language

C. Because different databases require different data models and query methods

D. Because database choice does not affect application design

Solution

1. Step 1: Understand database types

   SQL databases use structured tables, while NoSQL databases use flexible document or key-value models.

2. Step 2: Connect database type to app design

   The app must use different data models and queries depending on the database type chosen.

3. Final Answer:

   Because different databases require different data models and query methods -> Option C

4. Quick Check:

   Database type affects data model = D [OK]

Hint: Database type changes data structure and queries [OK]

Common Mistakes:

• Thinking all databases use the same query language
• Assuming database choice doesn't affect app design
• Believing Deno supports only one database type

2. Which of the following is the correct way to import a SQL client library in a Deno project?

easy

A. require('postgres');

B. import { Client } from "https://deno.land/x/postgres@v0.17.0/mod.ts";

C. import Client from 'postgres';

D. const Client = import('postgres');

Solution

1. Step 1: Recall Deno import syntax

   Deno uses ES module syntax with URL imports, not CommonJS require.

2. Step 2: Identify correct import statement

   import { Client } from "https://deno.land/x/postgres@v0.17.0/mod.ts"; uses correct ES module import with a URL and named import.

3. Final Answer:

   import { Client } from "https://deno.land/x/postgres@v0.17.0/mod.ts"; -> Option B

4. Quick Check:

   Deno uses ES module imports = A [OK]

Hint: Deno imports use URLs and ES module syntax [OK]

Common Mistakes:

• Using CommonJS require syntax
• Using bare module names without URLs
• Using default import when named import is required

3. Given this Deno code snippet using a NoSQL database client, what will be the output?

const db = new NoSQLClient();
await db.insert({ id: 1, name: "Alice" });
const user = await db.find({ id: 1 });
console.log(user.name);

medium

A. Alice

B. undefined

C. Error: insert method not found

D. null

Solution

1. Step 1: Understand NoSQL insert and find

   The insert method adds a document; find retrieves it by query.

2. Step 2: Trace code execution

   Insert adds user with id 1 and name Alice; find returns that user; console logs 'Alice'.

3. Final Answer:

   Alice -> Option A

4. Quick Check:

   Inserted user found and logged = Alice [OK]

Hint: Insert then find returns inserted data [OK]

Common Mistakes:

• Assuming find returns undefined if no await
• Confusing insert with update method
• Expecting error due to missing await

4. This Deno code tries to query a SQL database but throws an error. What is the likely cause?

const client = new Client();
await client.connect();
const result = await client.query('SELECT * FROM users WHERE id = $1', [1]);
console.log(result.rows[0].name);

medium

A. The console.log statement is incorrect

B. The query syntax is invalid for SQL

C. The query method does not support parameters

D. The Client constructor needs connection options

Solution

1. Step 1: Check Client initialization

   SQL clients in Deno require connection details (host, user, password) in constructor.

2. Step 2: Analyze error cause

   Without connection options, client.connect() fails, causing query error.

3. Final Answer:

   The Client constructor needs connection options -> Option D

4. Quick Check:

   Missing connection info causes error = A [OK]

Hint: SQL clients need connection info on creation [OK]

Common Mistakes:

• Assuming query syntax is wrong
• Thinking parameters are unsupported
• Blaming console.log for error

5. You want to build a Deno app that handles complex transactions and relationships between data. Which database choice best fits this need and why?

hard

A. SQL database, because it supports ACID transactions and relational data

B. In-memory database, because it is fastest for all data types

C. NoSQL database, because it handles flexible schemas well

D. Flat file storage, because it is simplest to implement

Solution

1. Step 1: Identify app requirements

   Complex transactions and relationships require strong data integrity and relations.

2. Step 2: Match database features

   SQL databases support ACID transactions and relational models, ideal for this need.

3. Final Answer:

   SQL database, because it supports ACID transactions and relational data -> Option A

4. Quick Check:

   Complex relations need SQL ACID support = C [OK]

Hint: Use SQL for complex transactions and relations [OK]

Common Mistakes:

• Choosing NoSQL for complex relational data
• Assuming in-memory is best for persistence
• Using flat files for transactional integrity