sum(field)

// 총 요청 수 계산
M::http_requests:(sum(request_count)) [1h]

// 서비스별로 그룹화하여 총 요청 수 계산
M::http_requests:(sum(request_count)) [1h] BY service

avg(field)

// 평균 응답 시간 계산
M::response_time:(avg(duration)) [1h] BY endpoint

// 평균 CPU 사용률 계산
M::cpu:(avg(usage)) [1h] BY host

count(field)
count(*)

// 로그 수 계산
L::nginx:(count(*)) [1h]

// 응답 시간이 있는 요청 수 계산
M::response_time:(count(duration)) [1h] BY service

min(field)
max(field)

// 최대 응답 시간 찾기
M::response_time:(max(duration)) [1h] BY endpoint

// CPU 사용률 범위 찾기
M::cpu:(min(usage), max(usage)) [1h] BY host

first(field)
last(field)
last_row(field)

// 최신 상태 값 가져오기
M::system:(last(status)) [1h] BY host

// 초기값 및 최종값 가져오기
M::counter:(first(value), last(value)) [1h] BY metric

any(field)

// 임의의 메시지 샘플 가져오기
L::logs:(any(message)) [1h] BY service

// 임의의 오류 스택 트레이스 가져오기
L::error_logs:(any(stack_trace)) [1h] BY error_type

<aggregate-or-subquery-measure> SHIFT <duration>

L::logs:(
  service,
  count(*) AS requests,
  count(*) SHIFT 7d AS requests_last_week,
  CASE
    WHEN (count(*) SHIFT 7d) = nil OR (count(*) SHIFT 7d) = 0 THEN nil
    ELSE count(*) / (count(*) SHIFT 7d)
  END AS requests_ratio
)[1d:1h] BY service

spread(field)

// 응답 시간의 변동 범위 계산
M::response_time:(spread(duration)) [1h] BY endpoint

stddev(field)

// 응답 시간의 표준 편차 계산
M::response_time:(stddev(duration)) [1h] BY endpoint

mode(field)

// 가장 일반적인 응답 상태 코드 찾기
M::http:(mode(status)) [1h] BY endpoint

count_series(field)

// CPU 메트릭을 보고하는 호스트 수 계산
M::cpu:(count_series(*)) [1h]

// 각 서비스의 인스턴스 수 계산
M::http_requests:(count_series(*)) [1h] BY service

count_distinct(field)

// 고유 사용자 수 통계
L::access_logs:(count_distinct(user_id)) [1d] BY service

// 액세스한 다른 IP 수 계산
L::nginx:(count_distinct(client_ip)) [1h] BY endpoint

percentile(field, n)
pXX(field)  // 약식 형식

// 응답 시간의 P99 계산
M::response_time:(percentile(duration, 99)) [1h] BY service

// 약식 형식 사용
M::response_time:(p99(duration)) [1h] BY service

// Rollup 함수 호출: 각 시계열에서 P95를 계산한 다음 service별로 집계
M::response_time:(avg(duration)) [1h::5m:percentile(95)] BY service

// 여러 백분위수 동시 계산
M::response_time:(p50(duration), p95(duration), p99(duration)) [1h] BY service

median(field)

// 응답 시간의 중앙값 계산
M::response_time:(median(duration)) [1h] BY service

histogram_auto(field)

// Nginx 액세스 로그의 응답 시간 분포 분석
L::nginx:(histogram_auto(response_time)) [1h]

// 서비스별 요청 지연 시간 분포 통계
L::app_logs:(histogram_auto(duration)) [1h] BY service

// Trace 호출의 지연 시간 분포 통계
T::http_client:(histogram_auto(elapsed)) [1h] BY operation

histogram(field, left_bound, right_bound, bucket_size [, threshold])

// 0-1000ms 범위에서 100ms 간격의 히스토그램 생성
M::response_time:(histogram(duration, 0, 1000, 100)) [1h]

// histogram_auto로 대체 권장
M::response_time:(histogram_auto(duration)) [1h]

histogram_quantile(field, q)

M::http_request_duration:(histogram_quantile(duration_bucket, 0.99)) [1h] BY service

histogram_quantile(0.99, sum(rate(http_request_duration_bucket[1h])) by (le, service))

M::http_request_duration:(
    histogram_quantile(duration_bucket, 0.95)
) [1h] BY service, endpoint

histogram_quantile(0.95, sum(rate(http_request_duration_bucket[1h])) by (le, service, endpoint))

M::http_request_duration:(
    histogram_quantile(duration_bucket, 0.50) as p50,
    histogram_quantile(duration_bucket, 0.99) as p99
) [1h] BY service

label_join(
  histogram_quantile(0.50, sum(rate(http_request_duration_bucket[1h])) by (le, service)), "quantile", "", "0.50"
)
or
label_join(
  histogram_quantile(0.99, sum(rate(http_request_duration_bucket[1h])) by (le, service)), "quantile", "", "0.99"
)

top(field, n)

// 응답 시간이 가장 긴 5개의 요청 가져오기
M::response_time:(top(duration, 5)) [1h] BY service

// 트래픽이 가장 많은 10개의 호스트 가져오기
M::network:(top(bytes, 10)) [1h]

bottom(field, n)

// 응답 시간이 가장 짧은 5개의 요청 가져오기
M::response_time:(bottom(duration, 5)) [1h] BY service

distinct(field)

// 모든 다른 상태 코드 가져오기
M::http:(distinct(status)) [1h] BY endpoint

distinct_by_collapse(field, [last_field1, last_field2, ...])

// 다른 사용자 ID 가져오기 및 각 사용자의 마지막 액세스 시간 유지
L::access_logs:(distinct_by_collapse(user_id, [timestamp])) [1h]

// 다른 호스트 가져오기 및 마지막 상태 및 메시지 유지
O::HOST:(distinct_by_collapse(host, [status, message])) [1h]

collect(field [, limit])

// 모든 응답 시간 수집
M::response_time:(collect(duration)) [1h] BY service

// 최대 100개의 값 수집
M::response_time:(collect(duration, 100)) [1h] BY service

collect_distinct(field [, limit])

// 모든 다른 오류 유형 수집
L::error_logs:(collect_distinct(error_type)) [1h] BY service

field_values(field)

// 모든 태그 값 가져오기
M::metrics:(field_values(tags)) [1h] BY metric_name

count_filter(field, [value1, value2, ...])

// 특정 상태 코드의 요청 수 계산
M::http:(count_filter(status, [200, 201, 204])) [1h] BY endpoint

// 오류 수준 로그 계산
L::logs:(count_filter(level, ["error", "critical"])) [1h] BY service

default(field, default_value)

// 빈 값에 기본 응답 시간 설정
M::response_time:(default(duration, 0)) [1h] BY service

// 요청 QPS 계산
M::http_requests:(sum(request_count)) [1h::5m:rate] BY service

// 약식 형식
M::cpu:(max(usage)) [rate]

// 알고리즘 매개변수가 있는 Rollup 함수 호출
M::cpu:(avg(usage)) [1h::1m:ewma(0.3)] BY host

rate(field)

// 요청 QPS 계산
M::http_requests:(sum(request_count)) [rate] BY service

// 데이터 쓰기 속도 계산
M::data_ingestion:(sum(bytes)) [rate] BY source

irate(field)

// 순간 요청 QPS 계산
M::http_requests:(sum(request_count)) [irate] BY service

increase(field)

// 총 요청 수 증가량 계산
M::http_requests:(sum(request_count)) [increase] BY service

rate_over_sum(field)

// 초당 평균 요청 수 계산
M::http_requests:(rate_over_sum(request_count)) [1h] BY service

rate_over_count(field)

// 초당 오류 로그 수 계산
L::error_logs:(rate_over_count(*)) [1h] BY error_type

// Counter 메트릭: 음이 아닌 변화율 계산(리셋으로 인한 음수 값 무시)
rate(field)

// Gauge 메트릭: 전체 변화율 계산(음수 값 포함)
deriv(field)

// Counter 메트릭: 요청 QPS 계산
M::requests:(rate(count)) [1h::5m] BY service

// Gauge 메트릭: 메모리 사용 변화율 계산
M::memory:(deriv(used)) [1h::5m] BY host

// Counter 메트릭: 음이 아닌 차이 계산(리셋으로 인한 음수 값 무시)
increase(field)

// Gauge 메트릭: 전체 차이 계산(음수 값 포함)
difference(field)

// Counter 메트릭: 요청 증가량 계산
M::requests:(increase(count)) [1h::5m] BY service

// Gauge 메트릭: 요청 수 변화(증가 또는 감소 가능)
M::requests:(difference(count)) [1h::5m] BY service

moving_average(field, n)

// 5점 이동 평균 계산
M::cpu:(moving_average(usage, 5)) [1h::1m] BY host

// Rollup 함수 호출: 먼저 각 시계열에 대해 5점 이동 평균을 계산한 다음 host별로 집계
M::cpu:(avg(usage)) [1h::1m:moving_average(5)] BY host

ewma(field, alpha)

// 명시적 집계 호출: Select 집계 단계에서 EWMA 계산
M::cpu:(ewma(usage, 0.3)) [1h::1m] BY host

// Rollup 함수 호출: 먼저 각 시계열에 대해 EWMA를 계산한 다음 host별로 집계
M::cpu:(avg(usage)) [1h::1m:ewma(0.3)] BY host

slope(field)

// 메모리 사용량의 증가 추세 계산
M::memory:(slope(used)) [1h::5m] BY host

zscore(field)

---

#### mad_score

최신 지점의 MAD(Median Absolute Deviation) 이상 점수를 계산합니다.

**구문:**

**설명:**

- 중앙값과 MAD를 사용하여 최신 지점의 편차 정도를 측정하며 평균/표준 편차보다 극단값에 더 강건합니다.
- 최소 2개의 유효한 포인트가 필요합니다. MAD가 0이면 null 값을 반환합니다.

**예제:**

---

#### change_score

창 내 시퀀스의 변이 점수를 계산하여 평균이 크게 전환된 시계열을 찾는 데 사용됩니다.

**구문:**

**설명:**

- 가능한 분할 지점을 열거하고 분할 지점 앞뒤 두 부분의 평균 차이를 비교한 후 합동 표준 편차로 정규화합니다.
- 최소 4개의 유효한 포인트가 필요합니다. 유효한 포인트가 부족하면 null 값을 반환합니다.

**예제:**

---

#### corr

두 숫자 필드 간의 Pearson 상관 계수를 계산합니다.

**구문:**

**설명:**

- 반환 값 범위는 일반적으로 `[-1, 1]`입니다.
- 최소 2개의 유효한 포인트 쌍이 필요합니다. 필드 중 하나에 변화가 없으면 null 값을 반환합니다.
- `corr`는 두 개의 입력 필드가 필요하므로 시간 절 Rollup 작성을 지원하지 않습니다.

**예제:**

---

#### cumsum

누적 합계를 계산합니다.

**구문:**

**예제:**

---

## 변환 함수

변환 함수는 필드 값에 대한 수학 연산, 유형 변환 또는 문자열 처리를 수행하는 데 사용됩니다.

### 수학 함수

#### abs

절대값을 계산합니다.

**구문:**

**예제:**

---

#### round / ceil / floor

반올림 함수.

**구문:**

**예제:**

---

#### log / log2 / log10

로그 함수.

**구문:**

**예제:**

---

### 유형 변환

#### int / uint / float / string / bool

유형 변환 함수.

**구문:**

**예제:**

---

### 문자열 함수

#### lower

문자열을 소문자로 변환합니다.

**구문:**

**매개변수:**

- `field`: 문자열 필드

**반환값:**
변환된 소문자 문자열을 반환합니다.

---

#### upper

문자열을 대문자로 변환합니다.

**구문:**

**매개변수:**

- `field`: 문자열 필드

**반환값:**
변환된 대문자 문자열을 반환합니다.

---

#### trim

문자열 양쪽 끝의 공백 문자를 제거합니다.

**구문:**

**매개변수:**

- `field`: 문자열 필드

**반환값:**
양쪽 끝 공백이 제거된 문자열을 반환합니다.

---

#### ltrim

문자열 왼쪽의 공백 문자를 제거합니다.

**구문:**

**매개변수:**

- `field`: 문자열 필드

**반환값:**
왼쪽 공백이 제거된 문자열을 반환합니다.

---

#### rtrim

문자열 오른쪽의 공백 문자를 제거합니다.

**구문:**

**매개변수:**

- `field`: 문자열 필드

**반환값:**
오른쪽 공백이 제거된 문자열을 반환합니다.

---

#### length

문자열 길이(문자 수 기준)를 반환합니다.

**구문:**

**매개변수:**

- `field`: 문자열 필드

**반환값:**
문자열 길이를 반환합니다.

---

#### substr

부분 문자열을 추출합니다.

**구문:**

**매개변수:**

- `field`: 문자열 필드
- `start`: 시작 위치(0부터 시작, 음수는 끝에서부터 시작을 의미)
- `length`(선택 사항): 부분 문자열 길이

**반환값:**
추출된 부분 문자열을 반환합니다.

**예제:**

**결과 예시:**

| message                     | substr(message, 0, 10) | substr(message, -5) |
| --------------------------- | ---------------------- | ------------------- |
| "Error: connection timeout" | "Error: con"           | "eout"              |

---

#### regexp_extract

정규 표현식 추출.

**구문:**

**매개변수:**

- `field`: 문자열 필드
- `pattern`: 정규 표현식
- `n`(선택 사항): n번째 캡처 그룹 추출, 기본값은 0(전체 일치)

**반환값:**
n번째 캡처 그룹의 내용을 포함하는 단일 문자열을 반환합니다. 일치하는 항목이 없으면 null을 반환합니다.

**예제:**

**결과 예시:**

| service | regexp_extract(message, 'error_code: (\\d+)', 1) |
| ------- | ------------------------------------------------ |
| api     | "404"                                            |
| api     | "500"                                            |
| web     | null                                             |

---

#### regexp_extract_all

모든 일치 결과를 추출합니다.

**구문:**

**반환값:**
모든 일치하는 부분 문자열을 포함하는 문자열 배열을 반환합니다.

**예제:**

**결과 예시:**

| message                              | regexp_extract_all(message, '\d+\.\d+\.\d+\.\d+', 0) |
| ------------------------------------ | ---------------------------------------------------- |
| Request from 192.168.1.1 to 10.0.0.1 | ["192.168.1.1", "10.0.0.1"]                          |

---

#### regexp_replace

정규 표현식을 사용하여 일치하는 텍스트를 바꿉니다.

**구문:**

**매개변수:**

- `field`: 문자열 필드
- `pattern`: 정규 표현식
- `replacement`: 바꿀 문자열; 캡처 그룹을 참조해야 하는 경우 `$1`, `${1}`, `$2` 등을 사용합니다. 캡처 그룹 뒤에 문자, 숫자 또는 밑줄이 오는 경우 `${1}`을 사용하여 모호성을 제거합니다(예: `${1}_suffix`). 리터럴 `$`를 출력해야 하는 경우 `$$`를 사용합니다.

**반환값:**
바꾼 후의 문자열을 반환합니다. 일치하는 항목이 없으면 원래 문자열을 반환합니다.

**예제:**

---

#### md5

MD5 해시 값을 계산합니다.

**구문:**

**반환값:**
32자리 16진수 문자열(소문자)을 반환합니다.

**예제:**

**결과 예시:**

| service | md5(message)                     |
| ------- | -------------------------------- |
| api     | 5d41402abc4b2a76b9719d911017c592 |
| web     | 098f6bcd4621d373cade4e832627b4f6 |

---

#### concat

문자열 연결.

**구문:**

**반환값:**
연결된 단일 문자열을 반환합니다.

**예제:**

**결과 예시:**

| service | level | concat(service, ":", level) |
| ------- | ----- | --------------------------- |
| api     | error | "api:error"                 |
| web     | info  | "web:info"                  |

---

#### set

배열 필드를 중복 제거하고 정렬합니다.

**구문:**

**반환값:**
중복 제거되고 정렬된 배열을 반환합니다.

**예제:**

**결과 예시:**

| metric_name | set(tags)                                  |
| ----------- | ------------------------------------------ |
| cpu_usage   | ["env:prod", "host:A", "team:backend"]     |
| memory_used | ["env:staging", "host:B", "team:frontend"] |

---

### 로그 클러스터링

#### drain

Drain 알고리즘을 사용하여 유사한 로그를 동일한 클래스로 그룹화하고 해당 클래스의 대표 로그 샘플을 반환합니다.

**구문:**

**매개변수:**

- `field`: 문자열 필드 또는 문자열 표현식, 일반적으로 `message`
- `similarity_threshold`: 유사도 임계값, 범위 `(0, 1]`; 값이 클수록 더 유사한 로그만 동일한 클래스로 그룹화됩니다.
- `max_clusters`: 선택 사항, 최대 클러스터 수, 범위 `[1, 10000]`; 생략 시 기본값은 `1000`입니다.

**반환값:**
문자열 유형의 대표 로그 샘플을 반환합니다. 샘플은 클러스터가 생성될 때의 원래 로그이며 Drain이 내부적으로 유지 관리하는 일반화된 템플릿이 아닙니다.

**알고리즘 설명:**

Drain은 구문 분석 트리 기반의 로그 클러스터링 알고리즘입니다. 함수는 실행 과정에서 지속적으로 클러스터러를 훈련합니다. 새 로그가 기존 클러스터와 일치하면 해당 클러스터의 대표 샘플을 반환하고, 일치하지 않으면 새 클러스터를 생성하고 현재 로그를 해당 클러스터의 대표 샘플로 설정합니다.

**사용 사례:**

- 유사한 로그 그룹별 통계
- 비정상 로그 클러스터 분석
- 로그 노이즈 감소

**예제:**

**결과 예시:**

| sample                                              | count(*) |
| --------------------------------------------------- | -------- |
| "Request from 192.168.1.1 to /api/users took 35 ms" | 128      |
| "Query SELECT * FROM orders executed in 18 ms"      | 42       |

---

## 매칭 함수

매칭 함수는 WHERE 절에서 텍스트 매칭에 사용되며 불리언 값을 반환하는 표현식으로도 사용할 수 있습니다.

### 부분 문자열 매칭

#### match

필드에 지정된 부분 문자열이 포함되어 있는지 확인합니다.

**구문:**

**매개변수:**

- `pattern`: 매칭할 부분 문자열
- `field`: 필드 이름(선택 사항, WHERE 절에서는 생략 가능)

**예제:**

---

### 구문 매칭

#### search

분석 구문 매칭, 중/영문 혼합 지원.

**구문:**

**매개변수:**

- `query`: 검색 구문
- `field`: 필드 이름(선택 사항)

**매칭 규칙:**

- 중국어: 문자 단위로 분석하여 매칭
- 영어: 단어 경계별 매칭(공백, 구두점으로 구분)
- 대소문자 구분하지 않음
- 비어 있지 않은 `query`가 정확히 한 쌍의 큰따옴표만 포함하고 큰따옴표가 전체 값을 감싸는 경우 구문 매칭으로 처리: 각 분석 단어가 인접하고 순서가 일치해야 함; 큰따옴표는 매칭 내용에 포함되지 않음
- 위 큰따옴표 특수 형식에서 공백 또는 구두점만 포함된 내용은 여전히 연속 리터럴 값으로 매칭
- 빈 쿼리 `""`는 위 특수 형식에 해당하지 않으며 일반 분석 검색 매개변수로 처리
- 큰따옴표가 포함된 다른 형식은 모두 합법적인 일반 분석 검색 매개변수로 처리되며 특별히 해석되지 않음. 예를 들어 한쪽 큰따옴표만 있는 경우, 값에 추가 큰따옴표가 포함된 경우 또는 큰따옴표가 양쪽 끝에 없는 경우

**예제:**

---

### 정규 표현식 매칭

#### re / regex / regexp

정규 표현식 매칭, 대소문자 구분.

**구문:**

**매개변수:**

- `pattern`: 정규 표현식(PromRegex 구문 지원)
- `field`: 필드 이름(선택 사항)

**예제:**

---

### 와일드카드 매칭

#### wildcard

와일드카드 패턴 매칭, 대소문자 구분.

**구문:**

---

### CIDR 매칭

#### cidr

IP 주소 네트워크 세그먼트 매칭.

**구문:**

**매개변수:**

- `cidr`: CIDR 표기법의 네트워크 세그먼트(예: `192.168.1.0/24`)
- `field`: IP 주소 필드(선택 사항)

**예제:**

---

### 필드 존재 확인

#### exists

필드가 존재하는지 확인합니다. `exists()`는 특수 자리 표시자이며 일반적으로 비교 표현식의 오른쪽에 사용됩니다.

**구문:**

**권장 사용법:**

**예제:**

---

### 쿼리 문자열 구문

#### query_string

쿼리 문자열 구문을 사용하여 복잡한 매칭을 수행합니다.

**구문:**

**매개변수:**

- `query`: 쿼리 문자열
- `field`: 필드 이름(선택 사항, 기본값은 전체 텍스트 매칭)

**쿼리 문자열 구문:**

##### 1. 용어 매칭

##### 2. 와일드카드

##### 4. 불리언 연산자

##### 5. 그룹화

##### 6. 기본 연산자

여러 용어가 공백으로 구분된 경우 기본적으로 OR로 연결됨(AND로 구성 가능):

##### 7. 분석 규칙

queryString 함수의 구체적인 동작은 현재 워크스페이스에서 사용 중인 기본 저장소 엔진에 따라 다릅니다.

- ScopeDB 환경: queryString은 대소문자를 구분하지 않는 포함 검색을 수행합니다. 즉, 필드 값에 쿼리 문자열의 임의 하위 문자열이 포함되어 있는지 매칭하며 분석을 포함하지 않습니다.

- Doris 환경: queryString은 전체 텍스트 인덱스 분석을 기반으로 매칭하며 그 의미는 분석 결과와 직접적으로 관련됩니다. Doris에서 사용하는 분석기는 [Unicode Standard Annex #29의 기본 단어 경계 사양](./funcs-unicode.md)을 따릅니다.


##### 예제

---

## 외부 함수

> **사용 권장 사항:** 외부 함수는 레거시 설계입니다. Rollup + 집계 함수(예: `[rate]`, `[last]`, `[increase]` 등)로 해결할 수 있는 시나리오는 **Rollup 방식을 우선 사용**합니다. 외부 함수는 Rollup이 적용되지 않는 시나리오(예: 집계 결과에 대한 2차 계산이 필요한 경우)에서만 사용합니다. `dbscan`, `forecast`와 같이 전체 쿼리 결과가 필요한 중심 감지/예측 함수는 동등한 Rollup 작성 방법이 없으므로 외부 함수로 사용합니다.

외부 함수는 전체 DQL 쿼리 결과에 대해 작동하며 쿼리 출력의 시계열 데이터에 대한 2차 계산을 수행하는 데 사용됩니다. 외부 함수는 전체 DQL 표현식을 감싸며 Select 절 내부에 작성되지 않습니다.

### 쿼리 내 함수와 외부 함수

- **쿼리 내 함수**: DQL 표현식 내부에서 사용되는 함수(예: `sum`, `avg`, `max` 등)
- **외부 함수**: 전체 DQL 쿼리 결과를 감싸서 출력 시계열을 후처리하는 함수

**작성 방법 비교:**

```dql
// Rollup(시간 절): 먼저 각 시계열에 대해 증가율을 계산한 다음 집계
M::http_requests:(sum(request_count)) [rate] BY service

// 외부 함수: 먼저 쿼리 결과를 얻은 다음 2차 계산 수행
rate(M::http_requests:(sum(request_count)) [1h::1m] BY service)

outer_function(DQL_expression)

// 쿼리 내 함수: 원시 데이터의 평균 계산
M::cpu:(avg(usage)) [1h::5m] BY host

// 외부 함수: 쿼리 결과에 대한 이동 평균 계산
moving_average(M::cpu:(avg(usage)) [1h::5m] BY host, 5)

cumsum(DQL_expression)

// 누적 요청 수 계산
cumsum(M::requests:(sum(count)) [1h::5m] BY service)

// 외부 함수: 쿼리 결과에 대한 미분 계산
derivative(M::cpu:(avg(usage)) [1h::5m] BY host)

// 권장: Rollup 방식 사용
M::cpu:(deriv(usage)) [1h::5m:last] BY host

moving_average(DQL_expression, n)

// 외부 함수: 쿼리 결과에 대한 이동 평균 계산
moving_average(M::cpu:(avg(usage)) [1h::1m] BY host, 5)

// 권장: Rollup 방식 사용
M::cpu:(moving_average(usage, 5)) [1h::1m] BY host

dbscan(DQL_expression)
dbscan(DQL_expression, eps)

// 기본 eps=0.5를 사용하여 CPU 사용률 이상값 감지
dbscan(M::cpu:(avg(usage)) [1h::5m] BY host)

// eps 명시적 지정
dbscan(M::cpu:(avg(usage)) [1h::5m] BY host, 0.8)

forecast(DQL_expression)
forecast(DQL_expression, steps)

// 미래 5개 시간 포인트 예측
forecast(M::cpu:(avg(usage)) [1h::5m] BY host)

// 미래 3개 시간 포인트 예측
forecast(M::cpu:(avg(usage)) [1h::5m] BY host, 3)

top(DQL_expression, n)
bottom(DQL_expression, n)

// 외부 함수: 쿼리 결과에 대한 TopN 가져오기
top(M::response_time:(max(duration)) [1h::5m] BY service, 5)

// 권장: Rollup 방식 사용
M::response_time:(top(duration, 5)) [1h::5m] BY service

// 0으로 null 값 채우기
fill(M::cpu:(avg(usage)) [1h::5m] BY host, 0)

// 선형 보간 채우기
fill(M::cpu:(avg(usage)) [1h::5m] BY host, LINEAR)

// 이동 평균 계산 후 반올림
round(moving_average(M::cpu:(avg(usage)) [1h::1m] BY host, 5))

// 증가율의 이동 평균 계산
moving_average(rate(M::requests:(sum(count)) [1h::5m] BY service), 3)

eval(expression, name1=(query1), name2=(query2), ..., alias="result_name")

// 오류율 = 오류 수 / 총 요청 수 * 100 계산
eval(a / b * 100,
     a=(M::http:(sum(error_count)) [1h] BY service),
     b=(M::http:(sum(request_count)) [1h] BY service),
     alias="error_rate")

// 사용률 = used / total * 100
eval(used / total * 100,
     used=(M::memory:(sum(used_bytes)) [1h] BY host),
     total=(M::memory:(sum(total_bytes)) [1h] BY host),
     alias="memory_usage_percent")

// 현재 값의 기준선 값에 대한 증가율 계산
eval(current / baseline - 1,
     current=(M::sales_current:(sum(amount)) [7d]),
     baseline=(M::sales_baseline:(sum(amount)) [7d]),
     alias="growth_rate")

// 하위 쿼리의 특정 필드 참조
eval(a.usage / b.total * 100,
     a=(M::cpu:(avg(usage) as usage) [1h] BY host),
     b=(M::cpu:(avg(total) as total) [1h] BY host),
     alias="cpu_percent")

fill(DQL_expression, value)
fill(DQL_expression, LINEAR)
fill(DQL_expression, PREVIOUS)

// 권장: 외부 함수로 사용
fill(M::cpu:(avg(usage)) [1h::5m] BY host, 0)

// 선형 보간 채우기
fill(M::cpu:(avg(usage)) [1h::5m] BY host, LINEAR)

// 이전 값으로 채우기
fill(M::cpu:(avg(usage)) [1h::5m] BY host, PREVIOUS)

now()

// 최근 업데이트된 데이터 쿼리
O::HOST:(*) {last_update_time > now() - 600000}  // 10분 내 업데이트

unwrap(field)

// 집계된 필드 래핑 해제
M::cpu:(unwrap(usage)) [1h] BY host

show_xxx(arg1=..., arg2=...){ where_conditions } [time_window] LIMIT n OFFSET m

show_logging_source()
show_tracing_field('mysql')
show_logging_field('*')
show_logging_label(name='env')
show_logging_label(names=['env', 'team'])