// Expression string 사용
cube.addMeasure('margin', { source: 'profit / sales * 100', aggregate: 'avg' });
cube.addMeasure('total_revenue', { source: 'price * quantity', aggregate: 'sum' });
 
// 함수 사용
cube.addMeasure('margin_pct', {
  source: (row) => row.sales > 0 ? (row.profit / row.sales * 100) : 0,
  aggregate: 'avg'
});
 
// aggregate에서 이름으로 참조
const agg = cube.aggregate(['region'], ['sales', 'margin', 'total_revenue']);

// Measure 등록
cube.addMeasure('profit', { source: 'profit', aggregate: 'sum' });
cube.addMeasure('sales', { source: 'sales', aggregate: 'sum' });
cube.addMeasure('qty', { source: 'qty', aggregate: 'sum' });
 
// Metric 등록
cube.addMetric('profit_margin', 'profit / sales * 100');
cube.addMetric('profit_per_qty', 'profit / qty');
 
// aggregate에서 함께 사용
const agg = cube.aggregate(['region'], [
  'profit',           // Measure
  'sales',            // Measure
  'profit_margin',    // Metric (자동으로 차원 필요)
  'profit_per_qty'    // Metric
]);

const slicer = cube.addSlicer({ name: 'region', dimension: 'region' });
slicer.select(['Seoul', 'Busan']);
cube.applySlicers();

// 동적 측정값 등록
cube.addMeasure('margin', { source: 'profit / sales * 100', aggregate: 'avg' });
 
// 런타임: immutable AggTable (캐시됨)
const agg1 = cube.aggregate(['region'], ['sales', 'margin']);
const agg2 = cube.aggregate(['region'], ['sales', 'margin']); // 캐시에서 재사용 ✓
 
// 디자인 타임: mutable AggTable (캐시 안됨)
const draft = cube.aggregate(['region'], ['sales'], { mutable: true });
draft.addDimension(productCol);    // 차원 추가
draft.removeMeasure('quantity');   // 측정값 제거
draft.freeze();                    // 확정 → 이후 캐시 가능
 
// aggregate 오버라이드: 기본 sum → avg로 변경
// metric (profit_rate)도 오버라이드된 sales(avg) 값을 사용
const aggAvg = cube.aggregate(['region'], ['sales', 'profit_rate'], {
    aggregates: { sales: 'avg' }
});
// sales: avg로 집계
// profit_rate = profit(sum) / sales(avg) * 100  ← 오버라이드된 값 사용
 
// 다중 오버라이드
const aggMulti = cube.aggregate(['region'], ['sales', 'quantity', 'avg_price'], {
    aggregates: { sales: 'avg', quantity: 'max' }
});
// avg_price = sales(avg) / quantity(max)

// 스키마: dimensions = ['region', 'product'], measures = ['sales', 'quantity']
const agg = cube.aggregateAll();
// 동일: cube.aggregate(['region', 'product'], ['sales', 'quantity'])

// 개별 변경: select()가 자동으로 applySlicers() 호출
cube.getSlicer('region')?.select(['Seoul']);
 
// 배치 변경: apply=false로 지연 후 직접 호출
cube.getSlicer('region')?.select(['Seoul'], false);
cube.getSlicer('category')?.select('Electronics', false);
cube.applySlicers();  // 한 번만 filterAll() 호출

table.beginUpdate();
try {
    table.setValue(0, 0, 'value1');
    table.setValue(0, 1, 'value2');
    table.updateRow(1, ['a', 'b', 'c']);
    // ... 여러 작업들
} finally {
    table.endUpdate();
}

{ region: 'Seoul', quarter: 'Q1' }
// region == 'Seoul' AND quarter == 'Q1'

{ sales: [1000, 5000] }  // 1000 <= sales <= 5000
{ quantity: [0, 100] }   // 0 <= quantity <= 100

// 기본 사용: 다중 정확한 값 필터
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// Seoul 지역, Q1 분기의 데이터만 추출
const dicedCube = cube.dice(
  new Map([
    ['region', 'Seoul'],
    ['quarter', 'Q1']
  ])
);
 
// 결과: region == 'Seoul' AND quarter == 'Q1'인 행만 포함
const agg = dicedCube.aggregate(['product'], ['sales']);

// 범위 필터 사용: 매출액 범위 제한
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 매출이 10,000 ~ 50,000 범위인 데이터만
const dicedCube = cube.dice(
  new Map([
    ['sales', [10000, 50000]]  // 10000 <= sales <= 50000
  ])
);
 
// 결과: 매출 범위에 해당하는 행만 포함
const agg = dicedCube.aggregate(['region'], ['quantity']);

// 혼합 필터: 정확한 값 + 범위 필터
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// Seoul 지역 + Q1 분기 + 판매량 50~100
const dicedCube = cube.dice(
  new Map([
    ['region', 'Seoul'],           // 정확한 값
    ['quarter', 'Q1'],             // 정확한 값
    ['quantity', [50, 100]]        // 범위 필터
  ])
);
 
// 결과: 모든 조건을 만족하는 행만 포함
const agg = dicedCube.aggregate(['product'], ['sales']);

// 복잡한 다중 조건 필터
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 여러 지역 + 가격대 + 시간 범위 조합
const dicedCube = cube.dice(
  new Map([
    ['region', 'Seoul'],          // 특정 지역
    ['product', 'A'],             // 특정 제품
    ['price', [1000, 5000]],      // 가격대
    ['date', ['2024-01-01', '2024-03-31']]  // 날짜 범위
  ])
);
 
// 모든 조건을 만족하는 상세 분석
const pivot = dicedCube.pivot(
  ['region', 'product'],
  ['quarter'],
  'sales'
);

// 빈 필터 맵 (필터링 없음)
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 필터 없이 전체 데이터
const dicedCube = cube.dice(new Map()); // 또는 new Map([])
 
// 원본 큐브와 동일한 결과
const agg1 = cube.aggregate(['region'], ['sales']);
const agg2 = dicedCube.aggregate(['region'], ['sales']);
// agg1과 agg2는 동일한 결과

// slice()와의 비교
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 방법 1: slice() 체이닝 (3번의 호출)
const result1 = cube
  .slice('region', 'Seoul')
  .slice('quarter', 'Q1')
  .slice('product', 'A')
  .aggregate(['date'], ['sales']);
 
// 방법 2: dice() 단일 호출
const result2 = cube
  .dice(new Map([
    ['region', 'Seoul'],
    ['quarter', 'Q1'],
    ['product', 'A']
  ]))
  .aggregate(['date'], ['sales']);
 
// 두 결과는 동일하지만 dice()가 더 효율적

// Excel pivot 스타일: 다중 필터와 피벗을 한 번에
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// Seoul 지역 + Q1 분기의 제품x날짜 피벗을 한 번에 생성
const pivot = cube.dice(
  new Map([
    ['region', 'Seoul'],
    ['quarter', 'Q1']
  ]),
  ['product'],    // 행 차원
  ['date'],       // 열 차원
  'sales'         // 측정값
);
 
// 결과는 PivotMatrix
console.log(pivot.rowLabels);    // [['A'], ['B']]
console.log(pivot.columnLabels); // [['2024-01-01'], ['2024-01-02'], ...]

// 단순 비교
const cube1 = cube.filter('sales > 1000');
const cube2 = cube.filter('region == "Seoul"');
 
// 논리 연산
const cube3 = cube.filter('sales > 1000 AND region == "Seoul"');
const cube4 = cube.filter('product == "A" OR product == "B"');
 
// IN 연산자
const cube5 = cube.filter('region IN ("Seoul", "Busan", "Daegu")');
 
// 범위 필터
const cube6 = cube.filter('sales BETWEEN 1000 AND 5000');
 
// 문자열 패턴
const cube7 = cube.filter('productName CONTAINS "Phone"');
const cube8 = cube.filter('productCode STARTSWITH "P-"');
 
// NULL 체크
const cube9 = cube.filter('discount IS NOT NULL');
 
// 복잡한 조합
const cube10 = cube.filter(
  '(region == "Seoul" OR region == "Busan") AND sales > 1000'
);

// 직접 사용 (현재 큐브가 변경됨)
cube.filterAll([
  { dimension: 'region', type: 'list', values: ['Seoul', 'Busan'] },
  { dimension: 'sales', type: 'range', range: [1000, 5000] }
]);
 
// 필터 초기화
cube.filterAll([]);

// year/month/day 계층의 경우
// 2024년만 필터 → 2024년의 모든 월, 일 자동 포함
cube.filterHierarchical('order_date', [2024])
 
// 명시적으로 특정 월만 선택
cube.filterHierarchical('order_date', [['2024', '01'], ['2024', '02']])
 
// 여러 연도의 특정 월
cube.filterHierarchical('order_date', [
  ['2024', '01'],
  ['2025', '01']
])

const cards = cube.getCardinalities();
// { region: 3, product: 5, quarter: 2, customer_id: 100000 }
 
// 카디날리티 100 이하인 차원만 피벗 축에 배치 가능
const pivotableDims = Object.entries(cards)
    .filter(([_, card]) => card <= 100)
    .map(([name]) => name);
// ['region', 'product', 'quarter']

const cube = new DataCube({source, schema});
 
// 지역 차원의 카디날리티
const regionCount = cube.getCardinality('region');  // 4 (O(1) - Dictionary 활용)
 
// 전체 차원의 카디날리티 확인
cube.schema.dimensions.forEach(dim => {
    console.log(`${dim.name}: ${cube.getCardinality(dim.name)}`);
});

cube.getChildDimensions('order_date.year'); // ['order_date.month']
cube.getChildDimensions('order_date.month'); // ['order_date.day']

// 원본 전체 고유값
const regions = cube.getColumnValues('region');
 
// 필터 적용된 고유값
const filtered = cube.getColumnValues('region', true);

const cube = new DataCube({source, schema});
 
// 판매량의 범위 확인
const salesRange = cube.getDimensionRange('sales');
// 반환: { min: 100, max: 50000 }
 
// 슬라이더 UI 구성
const range = cube.getDimensionRange('quantity');
if (range) {
    setupSlider({
        min: range.min,
        max: range.max,
        step: 10
    });
}
 
// 필터 후 범위 확인
const filtered = cube.slice('region', 'Seoul');
const seoulRange = filtered.getDimensionRange('sales');
// 반환: Seoul 지역의 판매량 범위

const dimensions = cube.getDimensions();
// [
//   { name: 'order_date.year', type: 'i32', parentDimension: undefined },
//   { name: 'order_date.month', type: 'str', parentDimension: 'order_date.year' },
//   { name: 'order_date.day', type: 'str', parentDimension: 'order_date.month' },
//   { name: 'region', type: 'str', parentDimension: undefined }
// ]

const measures = cube.getMeasures();
console.log(measures.map(m => m.name));  // ['sales', 'quantity', 'cost']

const fields = cube.getMeasuresAndMetrics();
// [
//   { name: 'sales', type: 'f64', role: 'measure', aggregate: 'sum', source: 'sales' },
//   { name: 'quantity', type: 'i32', role: 'measure', aggregate: 'sum', source: 'qty' },
//   { name: 'margin', type: 'f64', role: 'metric', source: 'profit / sales * 100' },
// ]
 
// UI에서 드롭다운 구성
const options = fields.map(f => ({ label: f.name, value: f.name }));

차원 2개 (문자열) + 측정값 3개 (숫자)
100행의 경우:
- 문자열 차원: 100 × (30 × 2 + 16) × 2 = 15,200바이트
- 숫자 측정값: 100 × 8 × 3 = 2,400바이트
- 오버헤드: 2,048바이트
- 합계: 약 19.6KB

5행(지역) × 4열(분기)의 피벗:
- 행 레이블: 5 × (10 × 2 + 16) = 180바이트
- 열 레이블: 4 × (5 × 2 + 16) = 104바이트
- 셀 데이터: 5 × 4 × 8 = 160바이트
- 오버헤드: 2,048바이트
- 합계: 약 2.5KB

const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 여러 집계 작업 수행
const agg1 = cube.aggregate(['region'], ['sales']);
const agg2 = cube.aggregate(['product'], ['sales']);
const agg3 = cube.aggregate(['date'], ['sales']);
 
// 캐시 메모리 확인
const usage = cube.getMemoryUsage();
console.log(`전체 메모리: ${(usage.total / 1024 / 1024).toFixed(2)}MB`);
 
// 캐시 제거하여 메모리 절약
cube.clearCache();
const usageAfter = cube.getMemoryUsage();
console.log(`캐시 제거 후: ${(usageAfter.total / 1024 / 1024).toFixed(2)}MB`);

// 방법 1: DataViewSource 사용 (복사 없음)
const viewSource = new DataViewSource(columns, dataView);
cube1.setSource(viewSource);  // 메모리 효율적
 
// 방법 2: ColumnStore 사용 (복사 + 최적화)
const columnStore = new ColumnStore(columns, dataFrame);
cube2.setSource(columnStore);  // 더 많은 메모리 사용

const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 전체 메모리
const fullUsage = cube.getMemoryUsage();
console.log(`전체: ${fullUsage.total}바이트`);
 
// 필터링된 큐브 (더 적은 메모리)
const filtered = cube.slice('region', 'Seoul');
const filteredUsage = filtered.getMemoryUsage();
console.log(`필터링: ${filteredUsage.total}바이트`);

const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 초기 메모리
console.log('=== 메모리 사용량 ===');
let usage = cube.getMemoryUsage();
console.log(`소스: ${(usage.source / 1024).toFixed(2)}KB`);
console.log(`집계: ${(usage.aggTables / 1024).toFixed(2)}KB`);
console.log(`피벗: ${(usage.pivotMatrices / 1024).toFixed(2)}KB`);
console.log(`총계: ${(usage.total / 1024).toFixed(2)}KB`);
 
// 집계 추가
cube.aggregate(['region'], ['sales']);
usage = cube.getMemoryUsage();
console.log(`
n집계 후: ${(usage.total / 1024).toFixed(2)}KB`);
 
// 피벗 추가
cube.pivot(['region'], ['quarter'], 'sales');
usage = cube.getMemoryUsage();
console.log(`피벗 후: ${(usage.total / 1024).toFixed(2)}KB`);

// 기본 사용
const cube = new DataCube();
cube.setSource(dataViewSource);
 
const usage = cube.getMemoryUsage();
console.log(`메모리 사용량: ${usage.total} 바이트`);
console.log(`소스: ${usage.source} 바이트`);
console.log(`집계: ${usage.aggTables} 바이트`);
console.log(`피벗: ${usage.pivotMatrices} 바이트`);

// 메모리 단위 변환
const cube = new DataCube();
cube.setSource(dataViewSource);
 
const usage = cube.getMemoryUsage();
 
// 바이트 → KB
const totalKB = usage.total / 1024;
console.log(`총 메모리: ${totalKB.toFixed(2)}KB`);
 
// 바이트 → MB
const totalMB = usage.total / 1024 / 1024;
console.log(`총 메모리: ${totalMB.toFixed(2)}MB`);

// 메모리 성장 추적
const cube = new DataCube();
cube.setSource(dataViewSource);
 
const memoryLog: { step: string; memory: number }[] = [];
 
// 초기 상태
memoryLog.push({
  step: '초기',
  memory: cube.getMemoryUsage().total
});
 
// 첫 번째 집계
cube.aggregate(['region'], ['sales']);
memoryLog.push({
  step: '집계1(region)',
  memory: cube.getMemoryUsage().total
});
 
// 두 번째 집계
cube.aggregate(['product'], ['sales']);
memoryLog.push({
  step: '집계2(product)',
  memory: cube.getMemoryUsage().total
});
 
// 피벗
cube.pivot(['region'], ['product'], 'sales');
memoryLog.push({
  step: '피벗(region×product)',
  memory: cube.getMemoryUsage().total
});
 
// 메모리 성장 확인
for (const log of memoryLog) {
  console.log(`${log.step}: ${(log.memory / 1024).toFixed(2)}KB`);
}

// 메모리 상한선 모니터링
const cube = new DataCube();
cube.setSource(dataViewSource);
 
const MAX_MEMORY_MB = 100; // 100MB 상한선
 
// 여러 집계 작업
const dimensions = [
  ['region'],
  ['product'],
  ['quarter'],
  ['region', 'product'],
  ['product', 'quarter'],
  ['region', 'quarter']
];
 
for (const dims of dimensions) {
  cube.aggregate(dims, ['sales', 'quantity']);
 
  const usage = cube.getMemoryUsage();
  const usageMB = usage.total / 1024 / 1024;
 
  console.log(`${dims.join('×')}: ${usageMB.toFixed(2)}MB`);
 
  // 상한선 초과 시 캐시 제거
  if (usageMB > MAX_MEMORY_MB) {
    console.log('경고: 메모리 상한선 초과! 캐시를 제거합니다.');
    cube.clearCache();
  }
}

const metrics = cube.getMetrics();
console.log(metrics.map(m => m.name));  // ['profit_margin', 'roi']

cube.getParentDimension('order_date.month'); // 'order_date.year'
cube.getParentDimension('order_date.year');  // undefined

cube.addMeasure('custom_cost', { source: 'cost * qty' });
cube.addMetric('custom_roi', 'profit / investment');
 
const schema = cube.getSchema();
// {
//   dimensions: [{ name: 'region', type: 'str' }, ...],
//   measures: [
//     { name: 'sales', type: 'f64', aggregate: 'sum' },
//     { name: 'custom_cost', type: 'f64', aggregate: 'sum' }, // 동적 추가됨
//     ...
//   ],
//   metrics: [
//     { name: 'margin', source: 'profit / sales * 100', type: 'f64' },
//     { name: 'custom_roi', source: '...' }, // 동적 추가됨
//     ...
//   ]
// }

const handler = (sender, row) => console.log(row);
table.on('onRowUpdated', handler);
table.off('onRowUpdated', handler);

table.on('onRowUpdated', (sender, row, oldValues) => {
    console.log('Row updated:', row);
});

const unsub = cube.onChange(() => {
    console.log('filters changed:', cube.getFilters());
});
// 해제
unsub();

cube.removeMeasure('old_measure');
cube.removeMeasure('cost')
    .removeMeasure('expense');

cube.removeMetric('profit_margin');
cube.removeMetric('roi')
    .removeMetric('margin_pct');

// 디버깅이나 에러 복구 시
if (table.isUpdating()) {
    console.warn('Event lock is stuck, resetting...');
    table.resetUpdate();
}

시간 계층:          조직 계층:              지역 계층:
년도                회사                   국가
 ↑                   ↑                      ↑
 분기               부서                   대륙
 ↑                   ↑                      ↑
 월                 팀                     국가
 ↑                   ↑                      ↑
 일                 개인                   지역

롤업 방향: 아래에서 위로 (세부 → 요약)

// 유효한 롤업 (fromDimension이 toDimension의 하위 계층)
rollUp('date', 'month')      // 일 → 월 ✓
rollUp('month', 'quarter')   // 월 → 분기 ✓
rollUp('quarter', 'year')    // 분기 → 연도 ✓
 
// 무효한 롤업
rollUp('month', 'date')      // 상위 → 하위 ✗ (드릴다운이어야 함)
rollUp('date', 'date')       // 동일 차원 ✗
rollUp('date', 'region')     // 관계없는 차원 ✗ (계층 관계 없음)

// 날짜별 판매량 데이터
2024-01-01: 100 판매량
2024-01-02: 150 판매량
2024-01-03: 120 판매량
 
// 월로 롤업 시 (Sum 집계)
2024-01: 370 판매량 (100+150+120)
 
// 월로 롤업 시 (Average 집계)
2024-01: 123.33 판매량 (평균값)

// 기본 사용: 일 → 월로 롤업
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 먼저 일별로 집계
const dayAgg = cube.aggregate(['date'], ['sales', 'quantity']);
// 결과: 2024-01-01, 2024-01-02, 2024-01-03, ... (상세)
 
// 월로 롤업하여 요약
const monthAgg = cube.rollUp('date', 'month');
// 결과: 2024-01, 2024-02, ... (요약)

// 다단계 롤업: 일 → 월 → 분기 → 연도
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// Step 1: 일별 판매 데이터
const dayData = cube.aggregate(['date'], ['sales']);
 
// Step 2: 월로 롤업
const monthData = cube.rollUp('date', 'month');
 
// Step 3: 분기로 롤업
const quarterData = cube.rollUp('month', 'quarter');
 
// Step 4: 연도로 롤업 (최상위 요약)
const yearData = cube.rollUp('quarter', 'year');
// 결과: 2024년의 총합 1건 (가장 요약된 형태)

// 조직 계층 롤업: 개인 → 팀 → 부서 → 회사
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 직원별 목표 달성률
const employeePerf = cube.aggregate(['employee'], ['target', 'actual']);
// 결과: 100명의 직원 데이터
 
// 팀 단위로 롤업 (평균 달성률)
const teamPerf = cube.rollUp('employee', 'team');
// 결과: 10개 팀의 평균 성과
 
// 부서 단위로 롤업
const deptPerf = cube.rollUp('team', 'department');
// 결과: 3개 부서의 평균 성과
 
// 회사 전체 성과
const companyPerf = cube.rollUp('department', 'company');
// 결과: 회사 전체 1개 행 (최종 요약)

// 지역 계층 롤업: 지점 → 지역 → 대구역 → 전국
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 지점별 매출
const storeData = cube.aggregate(['store'], ['sales']);
// 결과: 50개 지점
 
// 지역 단위로 롤업
const regionData = cube.rollUp('store', 'region');
// 결과: 8개 지역
 
// 대구역 단위로 롤업
const areaData = cube.rollUp('region', 'largeArea');
// 결과: 3개 대구역 (서부, 중부, 동부)
 
// 전국 단위 (최종)
const nationalData = cube.rollUp('largeArea', 'country');
// 결과: 전국 1개 행

// drillDown()과의 비교
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 연도 데이터에서 시작
const yearData = cube.aggregate(['year'], ['sales']);
// 2024년 총 매출: 1,000,000
 
// 방법 1: drillDown으로 분기 단위로 드릴다운
const quarterData = cube.drillDown('year', 'quarter');
// Q1: 200,000 / Q2: 300,000 / Q3: 250,000 / Q4: 250,000
 
// 방법 2: 분기에서 다시 month로 드릴다운
const monthData = cube.drillDown('quarter', 'month');
// Jan: 50,000 / Feb: 60,000 / ...
 
// 역방향: rollUp으로 월에서 분기로 롤업
const backToQuarter = cube.rollUp('month', 'quarter');
// Q1: 200,000 (다시 집계)

// 피벗과 함께 사용
const cube = new DataCube();
cube.setSource(dataViewSource);
 
// 일별 제품별 판매 데이터
const dailyData = cube.aggregate(['date', 'product'], ['sales']);
 
// 월로 롤업하여 월별 제품별 판매
const monthlyByProduct = cube.rollUp('date', 'month')
  .then(agg => {
    // 월별 제품별 피벗 생성
    return cube.pivot(['month'], ['product'], 'sales');
  });
 
// 결과: 월(행) x 제품(열) 의 크로스탭
// 형태: 12행 (월) x 5열 (제품) 매트릭스

// 집계 함수 변경
cube.updateMeasure('sales', { aggregate: 'avg' });
 
// Source 변경
cube.updateMeasure('cost', { source: 'actual_cost * rate' });
 
// 타입 변경
cube.updateMeasure('count', { type: 'i32' });
 
// 여러 속성 동시 변경
cube.updateMeasure('total', {
    source: 'amount * quantity',
    aggregate: 'sum',
    type: 'f64'
});

// 계산식 수정 (버그 수정)
cube.updateMetric('margin', 'profit / sales * 100');
 
// 다른 measure 참조로 변경
cube.updateMetric('ratio', 'revenue / cost');
 
// 메서드 체이닝
cube.updateMetric('m1', 'a + b')
    .updateMetric('m2', 'a * b');