Loading from databases in LangChain - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ component_behavior

intermediate

What does this LangChain database loader output?

Consider this LangChain code snippet that loads documents from a SQL database and prints the first document's content. What will be printed?

LangChain

from langchain.document_loaders import SQLDatabaseLoader
from langchain.sql_database import SQLDatabase

db = SQLDatabase.from_uri("sqlite:///example.db")
loader = SQLDatabaseLoader(db=db, table_name="users")
docs = loader.load()
print(docs[0].page_content)

A A list of all rows from the 'users' table printed as a list

B The content of the first row in the 'users' table as a string

C An error because 'load' method does not exist

D The database connection object printed as a string

💡 Hint

Remember that SQLDatabaseLoader loads rows as documents with page_content holding the row data.

The SQLDatabaseLoader loads each row from the specified table as a Document object. The 'page_content' attribute contains the row's data as a string. So printing docs[0].page_content shows the first row's content.

📝 Syntax

intermediate

Which option correctly initializes a LangChain loader for a PostgreSQL database?

You want to load documents from a PostgreSQL database named 'mydb' on localhost with user 'user' and password 'pass'. Which code snippet correctly creates the SQLDatabase and loader?

A

db = SQLDatabase.from_uri("postgresql://user:pass@localhost/mydb")
loader = SQLDatabaseLoader(db=db, table_name="documents")

B

db = SQLDatabase.from_uri("postgresql://user:pass@localhost/mydb")
loader = SQLDatabaseLoader(db=db, table="documents")

C

db = SQLDatabase.from_uri("postgresql://user:pass@localhost:5432/mydb")
loader = SQLDatabaseLoader(db=db, table_name="documents")

D

db = SQLDatabase.from_uri("postgres://user@localhost:pass/mydb")
loader = SQLDatabaseLoader(db=db, table="documents")

💡 Hint

The correct URI includes the port and the loader uses 'table_name' parameter.

Option C correctly specifies the PostgreSQL URI with port 5432 and uses 'table_name' parameter in SQLDatabaseLoader. Other options have wrong URI format or wrong parameter name.

🔧 Debug

advanced

Why does this LangChain database loader code raise an error?

Given this code snippet, why does it raise an AttributeError? from langchain.document_loaders import SQLDatabaseLoader from langchain.sql_database import SQLDatabase db = SQLDatabase.from_uri("sqlite:///example.db") loader = SQLDatabaseLoader(db=db) docs = loader.load()

A Because 'table_name' parameter is missing in SQLDatabaseLoader initialization

B Because 'load' method does not exist on SQLDatabaseLoader

C Because the database URI is invalid

D Because 'db' should be a connection string, not SQLDatabase object

💡 Hint

Check required parameters for SQLDatabaseLoader to know which table to load.

SQLDatabaseLoader requires the 'table_name' parameter to know which table to load. Omitting it causes an AttributeError when calling load().

❓ state_output

advanced

What is the length of the documents list after loading?

You run this code to load documents from a table with 3 rows: from langchain.document_loaders import SQLDatabaseLoader from langchain.sql_database import SQLDatabase db = SQLDatabase.from_uri("sqlite:///example.db") loader = SQLDatabaseLoader(db=db, table_name="notes") docs = loader.load() What is len(docs)?

A Raises an error

B 1

C 0

D 3

💡 Hint

Each row in the table becomes one Document in the list.

SQLDatabaseLoader.load() returns one Document per row in the specified table. Since the table has 3 rows, len(docs) is 3.

🧠 Conceptual

expert

Which statement best describes how LangChain's SQLDatabaseLoader handles database connections?

Select the most accurate description of how SQLDatabaseLoader manages connections when loading data from a database.

A SQLDatabaseLoader uses the SQLDatabase object which manages connection pooling internally, so connections are reused efficiently

B SQLDatabaseLoader requires the user to manually open and close the database connection before and after loading

C SQLDatabaseLoader opens a new connection for each load call and closes it automatically after loading

D SQLDatabaseLoader does not use any database connection; it only reads from local cache

💡 Hint

Think about how SQLDatabase abstracts connection management.

SQLDatabaseLoader relies on SQLDatabase which manages connections and pooling internally, allowing efficient reuse without manual connection handling.

Practice

1. What is the main purpose of using SQLDatabaseLoader in Langchain?

easy

A. To create a new database schema

B. To load data from a database using a SQL query

C. To save data into a database

D. To visualize database tables

Solution

1. Step 1: Understand the role of SQLDatabaseLoader

   It is designed to connect to a database and fetch data using SQL queries.

2. Step 2: Compare options with the purpose

   Only To load data from a database using a SQL query describes loading data from a database, which matches the loader's function.

3. Final Answer:

   To load data from a database using a SQL query -> Option B

4. Quick Check:

   Loading data = SQLDatabaseLoader usage [OK]

Hint: Loader means fetching data, not saving or creating [OK]

Common Mistakes:

• Confusing loading with saving data
• Thinking it creates database schemas
• Assuming it visualizes data

2. Which of the following is the correct way to initialize SQLDatabaseLoader with a database URI and a query?

easy

A. loader = SQLDatabaseLoader(query='sqlite:///mydb.db', uri='SELECT * FROM users')

B. loader = SQLDatabaseLoader('SELECT * FROM users', 'sqlite:///mydb.db')

C. loader = SQLDatabaseLoader(uri='sqlite:///mydb.db', query='SELECT * FROM users')

D. loader = SQLDatabaseLoader('mydb.db', 'SELECT * FROM users')

Solution

1. Step 1: Recall the parameter order and names

   The correct syntax uses named parameters: uri for the database URI and query for the SQL query.

2. Step 2: Match options with correct parameter usage

   Only loader = SQLDatabaseLoader(uri='sqlite:///mydb.db', query='SELECT * FROM users') correctly uses named parameters with proper values.

3. Final Answer:

   loader = SQLDatabaseLoader(uri='sqlite:///mydb.db', query='SELECT * FROM users') -> Option C

4. Quick Check:

   Named parameters uri and query = loader = SQLDatabaseLoader(uri='sqlite:///mydb.db', query='SELECT * FROM users') [OK]

Hint: Use named parameters uri and query in correct order [OK]

Common Mistakes:

• Swapping uri and query parameters
• Using positional arguments in wrong order
• Missing parameter names

3. Given the code below, what will be the output type of data after loading?

loader = SQLDatabaseLoader(uri='sqlite:///example.db', query='SELECT name FROM employees')
data = loader.load()

medium

A. A list of documents representing rows

B. A single string with all names concatenated

C. A dictionary with column names as keys

D. An integer count of rows

Solution

1. Step 1: Understand what loader.load() returns

   It returns a list of document objects, each representing a row from the query result.

2. Step 2: Compare output types

   Only A list of documents representing rows matches the expected list of documents; others describe different data types.

3. Final Answer:

   A list of documents representing rows -> Option A

4. Quick Check:

   load() returns list of documents [OK]

Hint: load() returns list of documents, not strings or dicts [OK]

Common Mistakes:

• Expecting a single string instead of list
• Thinking output is a dictionary
• Assuming it returns row count

4. Identify the error in the following code snippet for loading data from a database:

loader = SQLDatabaseLoader(uri='postgresql://user:pass@localhost/db', query='SELECT * FROM')
data = loader.load()

medium

A. The URI format is incorrect for PostgreSQL

B. The loader class name is misspelled

C. The load() method is missing parentheses

D. The SQL query is incomplete and will cause a syntax error

Solution

1. Step 1: Check the SQL query syntax

   The query 'SELECT * FROM' is incomplete because it lacks a table name, causing a syntax error.

2. Step 2: Verify other parts

   The URI format is correct, load() has parentheses, and class name is spelled correctly.

3. Final Answer:

   The SQL query is incomplete and will cause a syntax error -> Option D

4. Quick Check:

   Incomplete SQL query = syntax error [OK]

Hint: Check SQL query completeness first [OK]

Common Mistakes:

• Ignoring incomplete SQL query
• Misreading URI format
• Forgetting parentheses on load()

5. You want to load only active users from a database using Langchain's SQLDatabaseLoader. Which query and loader setup correctly filters active users assuming the table is users with a boolean column is_active?

hard

A. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active = 1')

B. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active')

C. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active = 'true'')

D. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE active = true')

Solution

1. Step 1: Understand SQL boolean filtering in SQLite

   SQLite uses 1 for true and 0 for false in boolean columns.

2. Step 2: Evaluate each query for correctness

   loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active = 1') correctly uses 'is_active = 1'. loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active') is incomplete, C has wrong quotes, D uses wrong column name.

3. Final Answer:

   loader = SQLDatabaseLoader(uri='sqlite:///app.db', query='SELECT * FROM users WHERE is_active = 1') -> Option A

4. Quick Check:

   Boolean true in SQLite = 1 [OK]

Hint: Use 'is_active = 1' for true in SQLite queries [OK]

Common Mistakes:

• Using wrong column name 'active'
• Incorrect SQL syntax for boolean values
• Missing comparison operator in WHERE clause