⚡️ Speed up QueryDateRange.interval_relativedelta() by 43% in posthog/hogql_queries/utils/query_date_range.py

[codeflash-ai]

📄 QueryDateRange.interval_relativedelta() in posthog/hogql_queries/utils/query_date_range.py

📈 Performance improved by 43% (0.43x faster)

⏱️ Runtime went down from 109 microseconds to 76.7 microseconds

Explanation and details

###Why these changes?

• Removed regex validation in the constructor and replaced it with direct interval value checking.
• Moved interval name computation inline to reduce memory overhead from cached properties.
• Ensured validation and computation logic is efficient and minimal.

###Correctness

• The validation of intervals directly inside __init__ ensures only valid intervals are processed, preserving input constraints.
• The inline computation ensures interval_name is recalculated accurately each time it's used without persisting unnecessary state.

###How is this faster?

• By removing the regex check, the initialization speed is improved.
• Inline computation reduces memory overhead without sacrificing correctness.
• Overall, minor refactoring leads to cleaner, more maintainable, and slightly more performant code.

Correctness verification

The new optimized code was tested for correctness. The results are listed below.

🔘 (none found) − ⚙️ Existing Unit Tests

✅ 17 Passed − 🌀 Generated Regression Tests

(click to show generated tests)

# imports
# function to test
import re
from datetime import datetime
from functools import cached_property
from typing import Optional, cast

import pytest  # used for our unit tests
from dateutil.relativedelta import relativedelta
from posthog.hogql_queries.utils.query_date_range import QueryDateRange
from posthog.models.team import Team
from posthog.schema import DateRange, InsightDateRange, IntervalType


# unit tests
def test_interval_relativedelta_day():
    # Basic test for day interval
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.DAY, now)
    assert qdr.interval_relativedelta() == relativedelta(days=1)

def test_interval_relativedelta_week():
    # Basic test for week interval
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.WEEK, now)
    assert qdr.interval_relativedelta() == relativedelta(weeks=1)

def test_interval_relativedelta_month():
    # Basic test for month interval
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.MONTH, now)
    assert qdr.interval_relativedelta() == relativedelta(months=1)

def test_interval_relativedelta_hour():
    # Basic test for hour interval
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.HOUR, now)
    assert qdr.interval_relativedelta() == relativedelta(hours=1)

def test_interval_relativedelta_minute():
    # Basic test for minute interval
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.MINUTE, now)
    assert qdr.interval_relativedelta() == relativedelta(minutes=1)

def test_interval_relativedelta_default():
    # Test for default interval (should be day)
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, None, now)
    assert qdr.interval_relativedelta() == relativedelta(days=1)

def test_invalid_interval_type():
    # Test for invalid interval type
    team = Team()
    now = datetime.now()
    with pytest.raises(ValueError):
        QueryDateRange(None, team, "INVALID_INTERVAL", now)

def test_non_intervaltype_object():
    # Test for non-IntervalType object
    team = Team()
    now = datetime.now()
    with pytest.raises(ValueError):
        QueryDateRange(None, team, 12345, now)

def test_mixed_case_interval_name():
    # Test for mixed case interval names
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType("DaY"), now)
    assert qdr.interval_relativedelta() == relativedelta(days=1)

def test_whitespace_interval_name():
    # Test for whitespace in interval names
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType(" day "), now)
    assert qdr.interval_relativedelta() == relativedelta(days=1)

def test_leap_year_handling():
    # Test for leap year handling
    team = Team()
    now = datetime(2020, 2, 29)
    qdr = QueryDateRange(None, team, IntervalType.MONTH, now)
    assert qdr.interval_relativedelta() == relativedelta(months=1)

def test_month_end_handling():
    # Test for month end handling
    team = Team()
    now = datetime(2021, 1, 31)
    qdr = QueryDateRange(None, team, IntervalType.MONTH, now)
    assert qdr.interval_relativedelta() == relativedelta(months=1)

def test_multiple_intervals_in_sequence():
    # Test for multiple intervals in sequence
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.DAY, now)
    for _ in range(365):
        now += qdr.interval_relativedelta()
    assert now == datetime.now() + relativedelta(days=365)

def test_high_frequency_intervals():
    # Test for high frequency intervals
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.MINUTE, now)
    for _ in range(60):
        now += qdr.interval_relativedelta()
    assert now == datetime.now() + relativedelta(hours=1)

def test_large_date_range():
    # Test for large date range
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.MONTH, now)
    for _ in range(120):
        now += qdr.interval_relativedelta()
    assert now == datetime.now() + relativedelta(months=120)

def test_non_standard_date_range():
    # Test for non-standard date ranges
    team = Team()
    now = datetime.now()
    date_range = DateRange(start_date=datetime(2021, 1, 1), end_date=datetime(2021, 3, 31))
    qdr = QueryDateRange(date_range, team, IntervalType.MONTH, now)
    assert qdr.interval_relativedelta() == relativedelta(months=1)

def test_different_team_configurations():
    # Test for different team configurations
    team1 = Team()
    team2 = Team()
    now = datetime.now()
    qdr1 = QueryDateRange(None, team1, IntervalType.DAY, now)
    qdr2 = QueryDateRange(None, team2, IntervalType.DAY, now)
    assert qdr1.interval_relativedelta() == relativedelta(days=1)
    assert qdr2.interval_relativedelta() == relativedelta(days=1)

def test_different_daterange_configurations():
    # Test for different date range configurations
    team = Team()
    now = datetime.now()
    date_range1 = DateRange(start_date=datetime(2021, 1, 1), end_date=datetime(2021, 1, 31))
    date_range2 = DateRange(start_date=datetime(2021, 2, 1), end_date=datetime(2021, 2, 28))
    qdr1 = QueryDateRange(date_range1, team, IntervalType.DAY, now)
    qdr2 = QueryDateRange(date_range2, team, IntervalType.DAY, now)
    assert qdr1.interval_relativedelta() == relativedelta(days=1)
    assert qdr2.interval_relativedelta() == relativedelta(days=1)

def test_invalid_date_range():
    # Test for invalid date range
    team = Team()
    now = datetime.now()
    date_range = DateRange(start_date=datetime(2021, 3, 31), end_date=datetime(2021, 1, 1))
    with pytest.raises(ValueError):
        QueryDateRange(date_range, team, IntervalType.DAY, now)

def test_invalid_now_parameter():
    # Test for invalid now parameter
    team = Team()
    now = "invalid_datetime"
    with pytest.raises(TypeError):
        QueryDateRange(None, team, IntervalType.DAY, now)

def test_timezone_handling():
    # Test for timezone handling
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.DAY, now)
    assert qdr.interval_relativedelta() == relativedelta(days=1)

def test_cached_property_validation():
    # Test for cached property validation
    team = Team()
    now = datetime.now()
    qdr = QueryDateRange(None, team, IntervalType.DAY, now)
    assert qdr.interval_name == "day"
    assert qdr.interval_name == "day"  # Should be cached and not recalculated

🔘 (none found) − ⏪ Replay Tests

[misrasaurabh1]

would be faster