Chuyển đến nội dung
MINH VO Ghi chép từ công việc
của một kỹ sư tại Việt Nam
Cơ bản7 phút đọc

Dùng khoảng nửa kín để trích xuất dữ liệu tăng dần

Giao sự kiện ranh giới vào đúng một khoảng bằng SQLite, kiểm tra ngày địa phương dài 23 hoặc 25 giờ và phân biệt dữ liệu đến muộn với lỗi chọn cận.

Biểu đồ phân tán màu ô liu, biểu đồ tần suất và bảng dữ liệu trên bàn màu be

Một sự kiện đúng lúc nửa đêm xuất hiện trong cả hai bản trích xuất hằng ngày. Từng truy vấn đều có vẻ hợp lý: lấy mọi thứ từ đầu ngày đến nửa đêm kế tiếp. Vấn đề là cả hai đều lấy điểm cuối chung. Cách sửa khác, dừng ở 23:59:59, lại bỏ mất sự kiện trong phần lẻ của giây cuối cùng.

Nếu bạn duy trì các tác vụ trích xuất dữ liệu phân tích theo lịch, bài này đưa ra một quy tắc ranh giới nhất quán và cách kiểm tra nó. Bạn cần hiểu phép so sánh trong SQL và biết chạy một ví dụ SQLite ngắn bằng Python. Các ví dụ dùng sự kiện giả lập, số nguyên micro giây và hai lần chuyển giờ thực tế. Chúng không chạy bộ điều phối hay đo hiệu năng xuất dữ liệu trong sản xuất.

Để khoảng tiếp theo nhận điểm ranh giới chung

Khoảng nửa kín lấy cận dưới và loại cận trên: lower <= event_time < upper. Với hai khoảng liền nhau [a, b) và [b, c), sự kiện đúng tại b không thỏa khoảng đầu nhưng thỏa khoảng sau. Mọi sự kiện trong [a, c) thuộc đúng một trong hai khoảng, với điều kiện chúng dùng cùng giá trị ranh giới và cùng cách biểu diễn thời gian để so sánh.

Từ đó có hai kiểm tra riêng: kết quả của hai khoảng không giao nhau, và hợp của chúng phải bằng kết quả của khoảng lớn hơn. Chỉ kiểm tra tổng số hàng có thể bỏ sót trường hợp một hàng trùng bù cho một hàng bị thiếu. Hãy giữ mã định danh sự kiện khi kiểm tra quy tắc.

Tài liệu về khoảng dữ liệu của Airflow phân biệt khoảng được giao cho một lần chạy với thời điểm tác vụ thực sự thực thi. Tác vụ chạy trễ vẫn phải dùng cận đã được giao. Trang này cũng lưu ý rằng khoảng của lần chạy kích hoạt thủ công phụ thuộc vào lịch và cách kích hoạt; suy ra khoảng trực tiếp từ ngày logic không phải cách thay thế đúng trong mọi trường hợp. Ví dụ dưới đây truyền cận trực tiếp và không triển khai lịch Airflow.

Hai khoảng ngày liền nhau chỉ giao sự kiện d ở nửa đêm chung cho ngày 02/07; truy vấn BETWEEN lấy cả hai cận sẽ chọn d hai lầnMở ảnh kích thước đầy đủ ↗

So sánh bằng một cách biểu diễn chính xác

Chạy lần lượt bốn khối Python trong cùng một phiên để giữ bảng sự kiện và các kết quả đối chiếu. Ví dụ dùng Python 3.12.3, SQLite 3.45.1 và dữ liệu múi giờ IANA 2026c của hệ thống. Mỗi sự kiện có mã định danh và một thời điểm kèm thông tin múi giờ. Ta đổi thời điểm đó thành số nguyên micro giây tính từ mốc UTC bằng phép toán số nguyên, tránh nhân một dấu thời gian số thực.

Các chuỗi được cung cấp có tối đa sáu chữ số phần lẻ. Đây là hàm chuyển đổi cho bộ dữ liệu minh họa, không phải bộ kiểm tra đầu vào thời gian tổng quát: bên nhập dữ liệu phải quy định cách xử lý độ chính xác cao hơn, thiếu độ lệch múi giờ và giá trị nguồn không hợp lệ. Bảng từ chối lưu dấu thời gian không phải số nguyên, nhưng không chứng minh bên cung cấp đã dùng đúng đơn vị cam kết. Những dấu thời gian Python thông thường này cũng không mô hình hóa giây nhuận.

from datetime import date, datetime, time, timedelta, timezone
from zoneinfo import ZoneInfo
import sqlite3

UTC = timezone.utc
EPOCH = datetime(1970, 1, 1, tzinfo=UTC)
DAY_US = 86_400_000_000


def epoch_us(instant):
    if instant.tzinfo is None or instant.utcoffset() is None:
        raise ValueError('an aware instant is required')
    delta = instant.astimezone(UTC) - EPOCH
    return ((delta.days * 86400 + delta.seconds) * 1_000_000
            + delta.microseconds)


def utc_us(text):
    return epoch_us(datetime.fromisoformat(text))


connection = sqlite3.connect(':memory:')
connection.execute('''CREATE TABLE events (
    event_id TEXT PRIMARY KEY,
    event_us INTEGER NOT NULL CHECK (typeof(event_us) = 'integer')
)''')
source = [
    ('a', '2026-06-30T23:59:59.999999+00:00'),
    ('b', '2026-07-01T00:00:00+00:00'),
    ('c', '2026-07-01T23:59:59.999999+00:00'),
    ('d', '2026-07-02T00:00:00+00:00'),
    ('e', '2026-07-02T12:00:00+00:00'),
    ('f', '2026-07-03T00:00:00+00:00'),
]
connection.executemany('INSERT INTO events VALUES (?, ?)',
                       [(key, utc_us(text)) for key, text in source])
connection.commit()
start = utc_us('2026-07-01T00:00:00+00:00')

Sự kiện a nằm trước khoảng hai ngày được chọn, còn f bắt đầu ngày tiếp theo. Trong khoảng cần lấy, b mở đầu ngày 01/07, c cách đầu ngày 02/07 một micro giây, d mở đầu ngày 02/07 và e xảy ra lúc trưa. Ví dụ cố ý đặt các hàng đúng nơi phép so sánh lấy cả hai cận sẽ cho kết quả khác.

Sắp xếp theo thời gian rồi mã định danh giúp thứ tự ổn định khi nhiều sự kiện có cùng dấu thời gian. Chúng có thể là những quan sát khác nhau. Quy tắc ranh giới giao chúng vào cùng một khoảng; nó không loại trùng theo dấu thời gian.

Làm rõ cả hai cách sai

Hàm trích xuất truyền cận qua tham số SQL. Nó chấp nhận khoảng không rỗng trong miền số nguyên có dấu của SQLite. Về toán học, khoảng rỗng là hợp lệ, nhưng giao diện tác vụ nhỏ này coi hai cận bằng nhau hoặc đảo thứ tự là lỗi cấu hình, thay vì trả về một bản xuất rỗng có vẻ thành công.

def extract(lower, upper):
    if type(lower) is not int or type(upper) is not int:
        raise ValueError('integer microsecond bounds required')
    if not -(1 << 63) <= lower < upper <= (1 << 63) - 1:
        raise ValueError('ordered, nonempty SQLite integer bounds required')
    return [row[0] for row in connection.execute(
        'SELECT event_id FROM events '
        'WHERE event_us >= ? AND event_us < ? '
        'ORDER BY event_us, event_id', (lower, upper))]


first = extract(start, start + DAY_US)
second = extract(start + DAY_US, start + 2 * DAY_US)
assert first == ['b', 'c']
assert second == ['d', 'e']
assert first + second == extract(start, start + 2 * DAY_US)
print(first, second)

inclusive = lambda lo, hi: [row[0] for row in connection.execute(
    'SELECT event_id FROM events WHERE event_us BETWEEN ? AND ? '
    'ORDER BY event_us, event_id', (lo, hi))]
assert inclusive(start, start + DAY_US) == ['b', 'c', 'd']
assert inclusive(start + DAY_US, start + 2 * DAY_US) == ['d', 'e', 'f']
# Ending at 23:59:59 discards c, which occurs during the final second.
assert inclusive(start, start + DAY_US - 1_000_000) == ['b']

Hai kết quả được in là ['b', 'c'] và ['d', 'e']. Ghép chúng lại trùng với khoảng lớn hơn trong bộ dữ liệu đã sắp thứ tự này. Các truy vấn đối chứng lấy cả hai cận trả về ['b', 'c', 'd'] và ['d', 'e', 'f']: d bị lặp, còn f lọt ra ngoài phạm vi hai ngày mong muốn.

Điều này đúng với định nghĩa BETWEEN của SQLite: nó tương đương x >= y AND x <= z, ngoại trừ việc chỉ tính x một lần. Từ khóa đó không ngầm tạo khoảng ngày có cận trên bị loại.

Đối chứng dừng ở 23:59:59 chỉ trả về b, bỏ mất c. Trừ một micro giây khỏi nửa đêm kế tiếp có thể dùng được với đúng cách biểu diễn rời rạc này, nhưng khiến truy vấn phụ thuộc vào một độ chính xác cụ thể. So sánh trực tiếp với cận trên bị loại giúp tránh duy trì thêm quy ước “thời điểm cuối cùng biểu diễn được” khi định dạng lưu trữ thay đổi.

Giữ điều kiện trên cột thời gian gốc và truyền vào các cận đã chuẩn hóa. Định dạng từng hàng thành chuỗi ngày đưa thêm một bước diễn giải và có thể làm thay đổi cách cơ sở dữ liệu truy cập dữ liệu. Bài này kiểm chứng các mã định danh được chọn, không khẳng định đã dùng chỉ mục hay đạt hiệu năng nào; hãy xem kế hoạch thực thi thật của hệ quản trị riêng.

Một ngày địa phương có thể dài 23 hoặc 25 giờ

Một ngày UTC trong ví dụ có 86.400 giây. Ngày nghiệp vụ được xác định bởi hai mốc nửa đêm địa phương có thể có thời lượng thực khác. Tại New York ngày 08/03/2026, khoảng từ nửa đêm đến nửa đêm tương ứng 05:00 UTC đến 04:00 UTC hôm sau, dài 23 giờ. Ngày 01/11 tương ứng 04:00 UTC đến 05:00 UTC hôm sau, dài 25 giờ.

Hãy dựng riêng cả hai cận ngày địa phương rồi chuyển từng cận sang dạng dùng để so sánh. Tài liệu datetime của Python giải thích rằng phép trừ hai giá trị có cùng tzinfo bỏ qua điều chỉnh múi giờ. Vì vậy mã đo thời lượng sau khi chuyển sang UTC, không trừ trực tiếp hai giá trị giờ trên đồng hồ địa phương.

def local_day_bounds(day, zone_name):
    zone = ZoneInfo(zone_name)
    begin = datetime.combine(day, time.min, tzinfo=zone)
    end = datetime.combine(day + timedelta(days=1), time.min, tzinfo=zone)
    return epoch_us(begin), epoch_us(end)


spring = local_day_bounds(date(2026, 3, 8), 'America/New_York')
autumn = local_day_bounds(date(2026, 11, 1), 'America/New_York')
assert (spring[1] - spring[0]) // 3_600_000_000 == 23
assert (autumn[1] - autumn[0]) // 3_600_000_000 == 25
fall_events = [
    ('n0', '2026-11-01T03:59:59.999999+00:00'),
    ('n1', '2026-11-01T04:00:00+00:00'),
    ('n2', '2026-11-01T05:30:00+00:00'),
    ('n3', '2026-11-01T06:30:00+00:00'),
    ('n4', '2026-11-02T04:59:59.999999+00:00'),
    ('n5', '2026-11-02T05:00:00+00:00'),
]
connection.executemany('INSERT INTO events VALUES (?, ?)',
                       [(key, utc_us(text)) for key, text in fall_events])
connection.commit()
assert extract(*autumn) == ['n1', 'n2', 'n3', 'n4']
assert extract(autumn[0], autumn[0] + DAY_US) == ['n1', 'n2', 'n3']
for _, text in fall_events[2:4]:
    print(datetime.fromisoformat(text).astimezone(ZoneInfo('America/New_York')).isoformat())

Truy vấn mùa thu trả về n1, n2, n3 và n4. Cộng cố định 24 giờ vào cận dưới sẽ bỏ mất n4, sự kiện nằm trong giờ cuối của ngày địa phương. Hai giá trị 01:30 được in có độ lệch -04:00 và -05:00. Chúng biểu diễn hai thời điểm khác nhau, đều thuộc ngày 01/11. ZoneInfo mô tả hành vi giờ lặp này và việc dùng cơ sở dữ liệu của hệ thống hoặc gói tzdata.

Hàm được minh họa với hai ngày ở New York có cận nửa đêm hợp lệ và không nhập nhằng. Nó không phải chính sách tổng quát cho nơi đổi giờ đúng nửa đêm hoặc bỏ qua một ngày lịch. Hãy kiểm tra cận lịch cho các múi giờ bạn hỗ trợ. Ở đây đầu vào sự kiện đã xác định thời điểm UTC; quyết định một giờ địa phương không có độ lệch thuộc lần xuất hiện nào là vấn đề riêng của bước nhập dữ liệu.

Ngày chuyển giờ mùa xuân ở New York dài 23 giờ UTC, còn ngày mùa thu dài 25 giờ; khoảng mùa thu cố định 24 giờ bỏ mất giờ cuối chứa n4Mở ảnh kích thước đầy đủ ↗

Ranh giới đúng không chứng minh dữ liệu đầy đủ

Giả sử một hàng chỉ xuất hiện sau lần trích xuất đầu tiên của ngày 01/07. Thời gian sự kiện của nó vẫn thuộc ngày 01/07. Điều kiện khoảng đúng không thể chọn hàng chưa có trong trạng thái nguồn mà truy vấn đã đọc.

# A newly visible row belongs to the old event-time interval.
connection.execute('INSERT INTO events VALUES (?, ?)',
                   ('late', utc_us('2026-07-01T12:00:00+00:00')))
connection.commit()
assert first == ['b', 'c']
assert extract(start, start + DAY_US) == ['b', 'late', 'c']
assert extract(start + DAY_US, start + 2 * DAY_US) == ['d', 'e']
print('saved:', first, 'repeated:', extract(start, start + DAY_US))

Kết quả đã lưu vẫn là ['b', 'c'], còn chạy lại với cùng cận trả về ['b', 'late', 'c']. Ngày 02/07 vẫn trả về ['d', 'e']. Khác biệt không đến từ khoảng chồng lấn; nguồn đã thay đổi. Chứng minh phân chia khoảng áp dụng cho một tập dữ liệu cố định. Các truy vấn riêng đọc nguồn đang thay đổi cần hợp đồng ảnh chụp hoặc phiên bản rõ ràng nếu hợp của chúng phải mô tả cùng một tập dữ liệu.

Pipeline sản xuất phải quyết định riêng khi nào khoảng nguồn đầy đủ, cách tìm dữ liệu đến muộn và cách thay thế hoặc đối soát đầu ra trước đó. Thử gửi lại và công bố đồng thời cũng cần quy tắc riêng. Cận nửa kín giải quyết sự kiện thuộc khoảng nào tại điểm chung; chúng không làm cho nguồn có thể thay đổi trở nên tái lập được.

Kiểm tra ranh giới bằng mã định danh

Sau cả bốn khối, thêm sự kiện g đúng lúc nửa đêm mở đầu ngày 02/07. Ngày 01/07 vẫn phải có b, late và c; ngày 02/07 giờ phải có d, g và e theo thứ tự đó. Sau đó thêm h trước nửa đêm này một micro giây. Nó chỉ thuộc ngày 01/07, cùng dấu thời gian với c. Hãy kiểm tra mã định danh, không chỉ tổng số hàng.

Khi rà soát vận hành, ghi lại đơn vị dấu thời gian, múi giờ dùng để xác định từng cận ngày, giá trị cận dưới và cận trên bị loại, cùng ảnh chụp hoặc phiên bản nguồn. Cơ sở dữ liệu múi giờ mới hay độ chính xác nguồn thay đổi có thể là lý do chạy lại các ca ranh giới. Bất biến cần giữ rất cụ thể: với cùng tập dữ liệu nguồn, các bản trích xuất liền nhau phủ đúng một lần toàn bộ khoảng lớn dự kiến.

Nguồn tham khảo & đọc thêm

  1. Apache Airflow DAG runs and data intervals
  2. SQLite expressions and BETWEEN
  3. Python 3.12 aware datetime arithmetic
  4. Python 3.12 IANA time zone support
← Về trang bài viết

Hình minh họa

100%