docs(source-bigquery): Add comprehensive incremental sync documentation (#62476)

Co-authored-by: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com>
Co-authored-by: [email protected] <[email protected]>

Author: devin-ai-integration[bot]

docs/integrations/sources/bigquery.md

@@ -44,6 +44,92 @@ The BigQuery data types mapping:
 | Change Data Capture | No        |       |
 | SSL Support         | Yes       |       |
 
+## Supported sync modes
+
+The BigQuery source connector supports the following [sync modes](https://docs.airbyte.com/cloud/core-concepts#connection-sync-modes):
+
+- **Full Refresh Sync**: Replaces all data in the destination with data from the source
+- **Incremental Sync**: Appends new records based on a cursor field
+
+### Incremental sync behavior
+
+Incremental sync uses a **cursor field** (typically a timestamp or incrementing ID) to track which records have been synced. The connector maintains state between syncs to resume from where the last sync left off.
+
+#### How incremental sync works
+
+The BigQuery source connector implements incremental sync by:
+
+1. **Querying with cursor filter**: Uses `WHERE cursor_field > last_cursor_value` to fetch only new records
+2. **State management**: Tracks the maximum cursor value from each sync for resumability
+3. **Parameterized queries**: Uses BigQuery's parameterized query API for efficient execution
+
+#### Cursor field requirements
+
+- **Monotonically increasing**: Must be a timestamp, auto-incrementing ID, or other always-increasing field
+- **Non-null values**: Records with null cursor values will be skipped
+- **Clustering/partitioning recommended**: For optimal query performance, choose a cursor field that aligns with your table's clustering or partitioning strategy
+- **Any data type supported**: The connector accepts any BigQuery data type as a cursor field
+
+#### Recommended cursor field types
+
+Based on BigQuery's query performance characteristics:
+
+1. **`TIMESTAMP`** - Best for time-based incremental sync, works well with BigQuery's time-based partitioning
+2. **`DATETIME`** - Good alternative to TIMESTAMP for timezone-agnostic scenarios  
+3. **`DATE`** - Suitable for daily batch incremental sync
+4. **`INT64`** - Excellent performance for auto-incrementing IDs
+5. **`STRING`** - Supported but slower than numeric/date types for large datasets
+
+#### BigQuery-specific performance considerations
+
+**Partitioned tables**: If your source table is partitioned by date/timestamp, choose a cursor field that aligns with the partition column for optimal performance.
+
+*Note: The SQL examples below illustrate the underlying query patterns that the connector generates. While you select cursor fields through Airbyte's UI, understanding these patterns helps you make informed choices that optimize BigQuery performance and reduce costs.*
+
+```sql
+-- Good: cursor field matches partition column
+WHERE _PARTITIONTIME > @cursor_value
+
+-- Less optimal: cursor field differs from partition column  
+WHERE updated_at > @cursor_value AND _PARTITIONTIME >= '2023-01-01'
+```
+
+**Clustered tables**: If your table is clustered, using a clustering column as the cursor field can significantly improve query performance.
+
+**Query slots**: Incremental queries consume BigQuery slots. For large tables:
+- Use more selective cursor fields when possible
+- Consider the frequency of incremental syncs vs. slot usage
+- Monitor query performance in BigQuery's query history
+
+#### State management and resumability
+
+- **Automatic state tracking**: The connector automatically saves the maximum cursor value after each successful sync
+- **Resume capability**: If a sync fails partway through, the next sync resumes from the last successfully processed cursor value  
+- **Manual state reset**: You can reset the sync state in Airbyte to re-sync historical data
+- **Per-stream state**: Each table/stream maintains independent cursor state
+
+#### Best practices for incremental sync
+
+1. **Choose the right cursor field**:
+   - Use `updated_at` or `modified_time` for frequently changing data
+   - Use `created_at` or `insert_time` for append-only data
+   - Choose fields that align with your table's clustering or partitioning for optimal performance
+
+2. **Optimize for BigQuery performance**:
+   - Align cursor fields with table partitioning when possible
+   - Use clustering columns as cursor fields for better performance
+   - Monitor BigQuery slot usage and query costs
+
+3. **Handle data quality**:
+   - Ensure cursor field values are always increasing
+   - Monitor for gaps in cursor field values that might indicate data quality issues
+   - Consider using `TIMESTAMP` fields over `DATETIME` for better timezone handling
+
+4. **Sync frequency considerations**:
+   - More frequent syncs reduce data latency but increase BigQuery slot usage
+   - Balance sync frequency with BigQuery costs and slot availability
+   - Consider BigQuery's streaming buffer behavior for very recent data
+
 ## Getting started
 
 ### Requirements