Why database choice affects architecture in Deno - Challenge Your Understanding

Challenge - 5 Problems

🧠 Conceptual

intermediate

How does choosing a SQL database influence application architecture?

Which architectural aspect is most directly influenced by choosing a SQL database over a NoSQL database?

A The elimination of the need for transactions

B The ability to store unstructured data without predefined schemas

C The use of eventual consistency models by default

D The need for strict schema design and relational data modeling

💡 Hint

Think about how SQL databases organize data and enforce rules.

SQL databases require a fixed schema and relational design, which affects how you structure your data and application logic.

❓ component_behavior

intermediate

Effect of database choice on data fetching components

In a Deno application, which behavior best describes a data fetching component when using a NoSQL database compared to a SQL database?

A It fetches data with flexible queries and often handles nested documents directly

B It requires complex JOIN operations to combine data from multiple tables

C It cannot handle JSON data formats natively

D It always uses strict ACID transactions for every read operation

💡 Hint

Consider how NoSQL databases store and retrieve data.

NoSQL databases often store nested or flexible data structures, so components can fetch complex documents without joins.

❓ state_output

advanced

Impact of database choice on application state consistency

What is the expected behavior of application state consistency when using a distributed NoSQL database with eventual consistency?

A The application must use strict locking to prevent conflicts

B The application always sees the most recent data immediately

C The application may temporarily see stale data before updates propagate

D The application cannot perform any concurrent writes

💡 Hint

Think about what eventual consistency means for data visibility.

Eventual consistency means updates take time to reach all nodes, so some reads may see older data temporarily.

📝 Syntax

advanced

Correct Deno code snippet for connecting to a SQL database

Which code snippet correctly establishes a connection to a PostgreSQL database in Deno using a popular client?

A

import { Client } from "https://deno.land/x/postgres@v0.17.0/mod.ts";
const client = new Client({ user: "user", database: "db", hostname: "localhost", password: "pass", port: 5432 });
await client.connect();

B

import { createClient } from "https://deno.land/x/redis@v0.29.0/mod.ts";
const client = createClient({ hostname: "localhost", port: 6379 });
await client.connect();

C

import { connect } from "https://deno.land/x/mysql@v2.10.0/mod.ts";
const client = await connect({ hostname: "localhost", username: "user", db: "db", password: "pass" });

D

import { MongoClient } from "https://deno.land/x/mongo@v0.31.1/mod.ts";
const client = new MongoClient();
await client.connect("mongodb://localhost:27017");

💡 Hint

Look for the PostgreSQL client import and connection pattern.

Option A uses the correct PostgreSQL client and connection method in Deno.

🔧 Debug

expert

Diagnose the cause of inconsistent data in a Deno app using a NoSQL database

A Deno app using a distributed NoSQL database shows inconsistent data reads after writes. Which is the most likely cause?

A The app is missing a required schema validation causing data corruption

B The database uses eventual consistency, so reads may return stale data temporarily

C The database connection string is incorrect, causing failed writes

D The app is using synchronous blocking calls causing race conditions

💡 Hint

Consider how distributed NoSQL databases handle data replication.

Eventual consistency means data updates take time to propagate, causing temporary stale reads.

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