Okay, you've successfully connected to your data source. The next big question is: how much data should you pull out during each extraction run? Do you grab everything every single time, or just the bits that are new or have changed? This choice leads us to two fundamental extraction strategies: Full Extraction and Incremental Extraction.

Understanding the difference and knowing when to use each is significant for building efficient and manageable ETL pipelines.

Full Extraction: Taking It All

Full extraction is exactly what it sounds like: every time the ETL process runs, it extracts the entire dataset from the source system. Think of it like photocopying an entire book every time you need to check for updates, even if only a few words changed.

How it Works: The process simply connects to the source and pulls all available records for the tables or files you're interested in. If the target system already contains data from a previous run, a full extraction typically involves deleting (truncating) the old data before loading the newly extracted complete dataset.

When to Use Full Extraction:

Initial Data Load: When you first set up your ETL pipeline and need to populate the target system (like a data warehouse) for the very first time, a full extraction is usually necessary.
Small Datasets: If the source dataset is relatively small (think thousands or maybe tens of thousands of records, depending on your systems), the overhead of a full extraction might be negligible. It's often simpler to implement than incremental logic.
Data Replication Needs: Sometimes, you need an exact replica of the source data at a specific point in time, and wiping the target clean before reloading ensures this.
Source System Limitations: If the source system doesn't provide a reliable way to track changes (like timestamps or version numbers), full extraction might be your only option.

Drawbacks of Full Extraction:

Performance: Extracting large volumes of data can be slow and consume significant computing resources on both the source and ETL systems.
Network Load: Transferring large datasets across a network can cause congestion and take a long time.
Source System Impact: Running large queries frequently can put a heavy load on the source database or application, potentially impacting its performance for operational users.
Time Consuming: The entire process takes longer, which might not be suitable if you need data updated frequently in your target system.

Incremental Extraction: Just the Changes, Please

Incremental extraction takes a more refined approach. Instead of grabbing everything, it identifies and extracts only the data that has been added or modified since the last extraction run. Going back to the book analogy, this is like only photocopying the pages where edits were made since your last copy.

How it Works: This method relies on being able to detect changes in the source data. Common techniques include:

Timestamps: Many database tables have columns that record when a row was last modified (e.g., last_updated_at, modification_date). The ETL process records the timestamp of the last successful extraction and, on the next run, only extracts rows with a timestamp later than the recorded one.
Version Numbers or Sequence IDs: Some systems assign incrementing numbers or unique IDs to transactions or records. You can track the last processed ID and fetch only records with higher IDs.
Status Flags: Sometimes, records have a status flag (e.g., is_processed, needs_sync) that indicates whether they need to be extracted. The ETL process extracts records with a specific flag and potentially updates the flag after successful extraction.
Change Data Capture (CDC): This is a more advanced set of techniques where the source database itself logs changes (inserts, updates, deletes) as they happen. Specialized CDC tools or database features can then read these logs to capture changes efficiently, often with very low latency. We'll touch upon CDC concepts later in this chapter.

When to Use Incremental Extraction:

Large Datasets: When dealing with tables containing millions or billions of records, extracting only the changes is vastly more efficient than a full extraction.
Frequent Updates: If data needs to be refreshed in the target system frequently (e.g., hourly or even more often), incremental extraction is usually the only feasible approach.
Resource Constraints: It reduces the load on the source system, the network, and the ETL processing engine.
Near Real-Time Requirements: CDC-based incremental extraction can enable data pipelines that operate with very low delays between a change occurring in the source and it reflecting in the target.

Drawbacks of Incremental Extraction:

Complexity: Implementing the logic to reliably detect changes can be more complex than simply selecting all data. You need a dependable mechanism (timestamps, IDs, CDC) in the source system.
Handling Deletes: Detecting deleted records can be tricky. Timestamps often only track inserts and updates. CDC systems or specific application logic (like "soft deletes" using a flag) are typically needed to capture deletions.
Potential for Missed Data: If the change detection mechanism isn't perfectly reliable or if an ETL run fails midway, there's a risk of missing some changes. Careful error handling and state management are required.
Dependency on Source: The effectiveness heavily relies on the features and reliability of the source system's change tracking mechanism.

Comparing the Approaches

Here's a simple diagram illustrating the core difference:

This diagram contrasts Full Extraction, which pulls all data every time, leading to replacement in the target, with Incremental Extraction, which pulls only new or changed data, allowing for appending or updating in the target.

Choosing the Right Strategy:

The decision between full and incremental extraction isn't always clear-cut and often depends on:

Data Volume: How large is the dataset? (Large -> Incremental)
Change Frequency: How often does the data change significantly? (Frequent -> Incremental)
Source System Capabilities: Does the source support reliable change tracking? (No -> Full, Yes -> Incremental)
Target Requirements: How up-to-date does the target data need to be? (Near real-time -> Incremental)
Development Complexity: How much complexity are you willing to manage? (Simple -> Full)

In many real-world scenarios, you might use a combination: perform an initial full extraction to populate the target system and then switch to incremental extractions for ongoing updates. Understanding both methods allows you to select the most appropriate technique for each specific data source in your ETL pipeline.