Loading from databases in LangChain - Step-by-Step Execution

Concept Flow - Loading from databases

Start

↓

Connect to DB

↓

Run Query

↓

Fetch Results

↓

Create LangChain Docs

↓

Use Docs in Chain

↓

End

This flow shows how LangChain connects to a database, runs a query, fetches results, converts them into documents, and uses them in a chain.

Execution Sample

LangChain

from langchain_community.document_loaders import SQLDatabaseLoader
from langchain_community.utilities import SQLDatabase

db = SQLDatabase.from_uri('sqlite:///example.db')
loader = SQLDatabaseLoader(db=db, query="SELECT * FROM table")
docs = loader.load()
print(len(docs))

This code connects to a SQLite database, loads data from a SQL query as documents, and prints how many documents were loaded.

Execution Table

Step	Action	Evaluation	Result
1	Create SQLDatabase and SQLDatabaseLoader with DB URL	db = SQLDatabase.from_uri('sqlite:///example.db'); loader = SQLDatabaseLoader(db=db, query="SELECT * FROM table")	Loader object ready
2	Call loader.load()	Runs SQL query to fetch rows	Data rows fetched from DB
3	Convert rows to LangChain Document objects	Each row becomes a Document	List of Document objects created
4	Print length of docs	len(docs)	Number of documents printed
5	End	All data loaded and ready for chain	Process complete

💡 All rows fetched and converted to documents, loading finished

Variable Tracker

Variable	Start	After Step 2	After Step 3	Final
loader	None	SQLDatabaseLoader instance	SQLDatabaseLoader instance	SQLDatabaseLoader instance
docs	None	None	List of Document objects	List of Document objects
len(docs)	N/A	N/A	N/A	Number of documents

Key Moments - 2 Insights

Why do we need to convert database rows into Document objects?

LangChain works with Document objects to process text data. The execution_table step 3 shows rows converted to Documents so chains can use them.

What happens if the database URL is incorrect?

The loader creation or load() call will fail to connect or fetch data, stopping execution early before step 2 in the execution_table.

Visual Quiz - 3 Questions

Look at the execution_table, what is the result after step 3?

A An error message

B Raw database rows

C A list of Document objects

D Empty list

💡 Hint

Check the 'Result' column in row for step 3 in execution_table

At which step does the actual database query run?

A Step 1

B Step 2

C Step 3

D Step 4

💡 Hint

Look at the 'Action' and 'Evaluation' columns in execution_table for step 2

If the database has 100 rows, what will len(docs) be after loading?

A 100

B 1

C 0

D Depends on the query

💡 Hint

Variable tracker shows docs is a list of Document objects created from rows

Concept Snapshot

Loading from databases in LangChain:
- Create SQLDatabase.from_uri & SQLDatabaseLoader(query, db)
- Call load() to fetch data
- Rows convert to Document objects
- Use docs in chains for processing
- Handles SQL databases easily

Full Transcript

This visual execution shows how LangChain loads data from a database. First, it creates SQLDatabase from URI and SQLDatabaseLoader with query and db. Then, calling load() runs a SQL query to fetch rows. These rows are converted into Document objects that LangChain can use. Finally, the number of documents is printed. This process lets you use database content in LangChain chains easily.

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