실시간 서비스 예시를 통한 Q, KDB+ 언어의 특징

이전 글에서 KDB+ 기반, Q 프로그래밍 언어가 무엇인지, 이들의 강점과 약점은 무엇인지 읽을 수 있습니다. 기사 그리고 간략하게 소개합니다. 이 기사에서는 들어오는 데이터 스트림을 처리하고 "실시간" 모드에서 매분마다 다양한 집계 함수를 계산하는 서비스를 Q에 구현합니다(즉, 데이터의 다음 부분 이전에 모든 것을 계산할 시간이 있음). Q의 주요 특징은 단일 개체가 아닌 배열, 배열 배열 및 기타 복잡한 개체로 작업할 수 있는 벡터 언어라는 것입니다. Q와 그 친척인 K, J, APL과 같은 언어는 간결함으로 유명합니다. Java와 같은 친숙한 언어로 여러 화면의 코드를 차지하는 프로그램을 몇 줄로 작성할 수 있는 경우가 많습니다. 이것이 제가 이 글에서 보여주고 싶은 것입니다.

소개

KDB+는 특정 방식(주로 시간 기준)으로 정렬된 매우 많은 양의 데이터에 초점을 맞춘 열 기반 데이터베이스입니다. 주로 은행, 투자 기금, 보험 회사 등 금융 기관에서 사용됩니다. Q 언어는 이 데이터를 효과적으로 작업할 수 있게 해주는 KDB+의 내부 언어입니다. Q 이데올로기는 간결성과 효율성을 추구하는 반면 명확성은 희생됩니다. 이는 벡터 언어가 어떤 경우에도 이해하기 어려울 것이라는 사실에 의해 정당화되며, 녹음의 간결함과 풍부함을 통해 프로그램의 훨씬 더 많은 부분을 한 화면에서 볼 수 있어 궁극적으로 이해하기가 더 쉬워집니다.

이 기사에서는 Q에서 완전한 프로그램을 구현하고 이를 시험해 보고 싶을 수도 있습니다. 이렇게 하려면 실제 Q가 필요합니다. kx 회사 웹사이트에서 무료 32비트 버전을 다운로드할 수 있습니다. www.kx.com. 관심이 있으시면 책 Q에 대한 참고 정보를 찾아보실 수 있습니다. Q 필사자를 위한 이 주제에 관한 다양한 기사.

문제 성명

25밀리초마다 데이터가 포함된 테이블을 보내는 소스가 있습니다. KDB+는 주로 금융에서 사용되므로 이것이 거래(거래) 테이블이라고 가정하고 다음 열이 있습니다: time(밀리초 단위의 시간), Sym(증권거래소의 회사 지정 - IBM, AAPL,…), 가격(주식을 구매한 가격), 규모(거래 규모). 25밀리초 간격은 임의적이며 너무 작지도 길지도 않습니다. 그 존재는 데이터가 이미 버퍼링된 서비스로 제공된다는 것을 의미합니다. 현재 로드에 따른 동적 버퍼링을 포함하여 서비스 측에서 버퍼링을 구현하는 것은 쉽지만 단순화를 위해 고정된 간격에 중점을 두겠습니다.

서비스는 최대 가격, 평균 가격, 합계 크기 등 집계 함수 집합을 사용하여 Sym 열에서 들어오는 각 기호에 대해 매분 계산해야 합니다. 유용한 정보. 단순화를 위해 모든 함수를 증분식으로 계산할 수 있다고 가정하겠습니다. 새로운 값을 얻으려면 이전 값과 들어오는 값이라는 두 숫자를 아는 것으로 충분합니다. 예를 들어 max,average,sum 함수에는 이 속성이 있지만 median 함수에는 없습니다.

또한 들어오는 데이터 스트림이 시간 순서대로 진행된다고 가정합니다. 이것은 우리에게 마지막 순간에만 일할 수 있는 기회를 줄 것입니다. 실제로 일부 업데이트가 늦어지는 경우를 대비해 현재 및 이전 분을 사용하여 작업할 수 있으면 충분합니다. 단순화를 위해 이 경우는 고려하지 않겠습니다.

집계 함수

필요한 집계 함수는 다음과 같습니다. 서비스 부하를 늘리기 위해 가능한 한 많은 항목을 사용했습니다.

• 높음 – 최대 가격 – 분당 최대 가격.
• 최저가 – 최저 가격 – 분당 최저 가격.
• firstPrice – 첫 번째 가격 – 분당 첫 번째 가격입니다.
• lastPrice – 마지막 가격 – 분당 마지막 가격.
• firstSize – 첫 번째 크기 – 분당 첫 번째 거래 크기.
• lastSize – 마지막 크기 — XNUMX분 동안의 마지막 거래 크기입니다.
• numTrades – count i – 분당 거래 수.
• 거래량 - 합계 크기 - 분당 거래 크기의 합계입니다.
• pvolume – 합계 가격 – avgPrice에 필요한 분당 가격 합계입니다.
• – 총 회전율 가격*크기 – 분당 총 거래량.
• avgPrice – pvolume%numTrades – 분당 평균 가격.
• avgSize – 볼륨%numTrades – 분당 평균 거래 규모.
• vwap – 매출액%볼륨 – 거래 규모에 따른 분당 평균 가격.
• cumVolume – 총량 – 전체 시간 동안 누적된 트랜잭션 크기입니다.

명확하지 않은 한 가지 사항, 즉 처음으로 그리고 이후의 매 순간마다 이러한 열을 초기화하는 방법에 대해 즉시 논의해 보겠습니다. firstPrice 유형의 일부 열은 매번 null로 초기화되어야 하며 해당 값은 정의되지 않습니다. 다른 볼륨 유형은 항상 0으로 설정해야 합니다. 결합된 접근 방식이 필요한 열도 있습니다. 예를 들어 cumVolume은 이전 분에서 복사해야 하고 첫 번째 분의 경우 0으로 설정해야 합니다. 사전 데이터를 사용하여 이러한 모든 매개변수를 설정하겠습니다. 유형(레코드와 유사):

// list ! list – создать словарь, 0n – float null, 0N – long null, `sym – тип символ, `sym1`sym2 – список символов
initWith:`sym`time`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover`avgPrice`avgSize`vwap`cumVolume!(`;00:00;0n;0n;0n;0n;0N;0N;0;0;0.0;0.0;0n;0n;0n;0);
aggCols:reverse key[initWith] except `sym`time; // список всех вычисляемых колонок, reverse объяснен ниже

편의를 위해 사전에 기호와 시간을 추가했습니다. 이제 initWith는 최종 집계 테이블에서 미리 만들어진 라인으로, 올바른 기호와 시간을 설정하는 데 남아 있습니다. 이를 사용하여 테이블에 새 행을 추가할 수 있습니다.

집계 함수를 생성할 때 aggCols가 필요합니다. Q의 표현식이 평가되는 순서(오른쪽에서 왼쪽으로)로 인해 목록이 반전되어야 합니다. 일부 열은 이전 열에 종속되므로 계산이 높은 것에서 cumVolume으로 진행되도록 하는 것이 목표입니다.

이전 분에서 새 분으로 복사해야 하는 열에는 편의를 위해 기호 열이 추가됩니다.

rollColumns:`sym`cumVolume;

이제 업데이트 방법에 따라 열을 그룹으로 나누어 보겠습니다. 세 가지 유형을 구분할 수 있습니다.

1. 누산기(볼륨, 회전율,..) – 이전 값에 들어오는 값을 추가해야 합니다.
2. 특수 지점(높음, 낮음, ..)의 경우 분당 첫 번째 값은 수신 데이터에서 가져오고 나머지는 함수를 사용하여 계산됩니다.
3. 나머지. 항상 함수를 사용하여 계산됩니다.

다음 클래스에 대한 변수를 정의해 보겠습니다.

accumulatorCols:`numTrades`volume`pvolume`turnover;
specialCols:`high`low`firstPrice`firstSize;

계산 순서

집계된 테이블은 두 단계에 걸쳐 업데이트됩니다. 효율성을 위해 먼저 각 문자 및 분에 대해 하나의 행만 있도록 수신 테이블을 축소합니다. 우리의 모든 기능이 증분적이고 연관적이라는 사실은 이 추가 단계의 결과가 변경되지 않음을 보장합니다. 선택을 사용하여 테이블을 축소할 수 있습니다.

select high:max price, low:min price … by sym,time.minute from table

이 방법에는 단점이 있습니다. 계산된 열 집합이 미리 정의되어 있다는 것입니다. 다행히 Q에서는 select가 동적으로 생성된 인수를 대체할 수 있는 함수로도 구현됩니다.

?[table;whereClause;byClause;selectClause]

인수 형식에 대해서는 자세히 설명하지 않겠습니다. 우리의 경우 by 및 select 표현식만 중요하며 columns!expressions 형식의 사전이어야 합니다. 따라서 축소 함수는 다음과 같이 정의할 수 있습니다.

selExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover!parse each ("max price";"min price";"first price";"last price";"first size";"last size";"count i";"sum size";"sum price";"sum price*size"); // each это функция map в Q для одного списка
preprocess:?[;();`sym`time!`sym`time.minute;selExpression];

명확성을 위해 Q 표현식이 포함된 문자열을 eval 함수에 전달할 수 있고 함수 select에 필요한 값으로 바꾸는 구문 분석 함수를 사용했습니다. 또한 전처리는 select 함수의 투영(즉, 부분적으로 정의된 인수가 있는 함수)으로 정의되며 인수 하나(테이블)가 누락되었습니다. 테이블에 전처리를 적용하면 압축된 테이블이 생성됩니다.

두 번째 단계는 집계된 테이블을 업데이트하는 것입니다. 먼저 의사 코드로 알고리즘을 작성해 보겠습니다.

for each sym in inputTable
  idx: row index in agg table for sym+currentTime;
  aggTable[idx;`high]: aggTable[idx;`high] | inputTable[sym;`high];
  aggTable[idx;`volume]: aggTable[idx;`volume] + inputTable[sym;`volume];
  …

Q에서는 루프 대신 맵/리듀스 함수를 사용하는 것이 일반적입니다. 그러나 Q는 벡터 언어이고 모든 연산을 모든 기호에 한 번에 쉽게 적용할 수 있으므로 루프 없이 모든 기호에 대한 연산을 한 번에 수행하여 첫 번째 근사를 수행할 수 있습니다.

idx:calcIdx inputTable;
row:aggTable idx;
aggTable[idx;`high]: row[`high] | inputTable`high;
aggTable[idx;`volume]: row[`volume] + inputTable`volume;
…

하지만 더 나아갈 수 있습니다. Q에는 독특하고 매우 강력한 연산자, 즉 일반화된 할당 연산자가 있습니다. 인덱스, 함수 및 인수 목록을 사용하여 복잡한 데이터 구조에서 값 집합을 변경할 수 있습니다. 우리의 경우에는 다음과 같습니다:

idx:calcIdx inputTable;
rows:aggTable idx;
// .[target;(idx0;idx1;..);function;argument] ~ target[idx 0;idx 1;…]: function[target[idx 0;idx 1;…];argument], в нашем случае функция – это присваивание
.[aggTable;(idx;aggCols);:;flip (row[`high] | inputTable`high;row[`volume] + inputTable`volume;…)];

안타깝게도 테이블에 할당하려면 열이 아닌 행 목록이 필요하며 뒤집기 기능을 사용하여 행렬(열 목록을 행 목록으로)을 바꿔야 합니다. 큰 테이블의 경우 비용이 많이 들기 때문에 대신 map 함수(아포스트로피처럼 보임)를 사용하여 각 열에 개별적으로 일반화된 할당을 적용합니다.

.[aggTable;;:;]'[(idx;)each aggCols; (row[`high] | inputTable`high;row[`volume] + inputTable`volume;…)];

우리는 다시 함수 투영을 사용합니다. 또한 Q에서 목록을 생성하는 것도 함수이며 목록의 목록을 얻기 위해 각각(map) 함수를 사용하여 이를 호출할 수 있습니다.

계산된 열 집합이 고정되지 않았는지 확인하기 위해 위 식을 동적으로 생성합니다. 먼저 집계된 데이터와 입력 데이터를 참조하기 위해 row 및 inp 변수를 사용하여 각 열을 계산하는 함수를 정의해 보겠습니다.

aggExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`avgPrice`avgSize`vwap`cumVolume!
 ("row[`high]|inp`high";"row[`low]&inp`low";"row`firstPrice";"inp`lastPrice";"row`firstSize";"inp`lastSize";"pvolume%numTrades";"volume%numTrades";"turnover%volume";"row[`cumVolume]+inp`volume");

일부 열은 특별하므로 해당 열의 첫 번째 값은 함수로 계산되어서는 안 됩니다. row[`numTrades] 열을 통해 첫 번째 항목임을 확인할 수 있습니다. 0이 포함된 경우 값이 첫 번째 항목입니다. Q에는 첫 번째 인수의 조건에 따라 목록 1 또는 2에서 값을 선택하는 선택 기능인 ?[Boolean list;list1;list2]가 있습니다.

// high -> ?[isFirst;inp`high;row[`high]|inp`high]
// @ - тоже обобщенное присваивание для случая когда индекс неглубокий
@[`aggExpression;specialCols;{[x;y]"?[isFirst;inp`",y,";",x,"]"};string specialCols];

여기서는 내 함수(중괄호 안의 표현식)를 사용하여 일반화된 할당을 호출했습니다. 현재 값(첫 번째 인수)과 추가 인수를 수신하며, 이를 네 번째 매개변수에 전달합니다.

기능이 동일하므로 배터리 스피커를 별도로 추가해 보겠습니다.

// volume -> row[`volume]+inp`volume
aggExpression[accumulatorCols]:{"row[`",x,"]+inp`",x } each string accumulatorCols;

이는 Q 기준으로는 일반적인 할당인데, 값 목록을 한번에 할당하는 것입니다. 마지막으로 main 함수를 만들어 보겠습니다.

// ":",/:aggExprs ~ map[{":",x};aggExpr] => ":row[`high]|inp`high" присвоим вычисленное значение переменной, потому что некоторые колонки зависят от уже вычисленных значений
// string[cols],'exprs ~ map[,;string[cols];exprs] => "high:row[`high]|inp`high" завершим создание присваивания. ,’ расшифровывается как map[concat]
// ";" sv exprs – String from Vector (sv), соединяет список строк вставляя “;” посредине
updateAgg:value "{[aggTable;idx;inp] row:aggTable idx; isFirst_0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols;(",(";"sv string[aggCols],'":",/:aggExpression aggCols),")]}";

이 표현식을 사용하여 위에서 제공한 표현식이 포함된 문자열에서 함수를 동적으로 생성합니다. 결과는 다음과 같습니다:

{[aggTable;idx;inp] rows:aggTable idx; isFirst_0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols ;(cumVolume:row[`cumVolume]+inp`cumVolume;… ; high:?[isFirst;inp`high;row[`high]|inp`high])]}

Q에서는 평가 순서가 오른쪽에서 왼쪽이므로 열 평가 순서가 반전됩니다.

이제 계산에 필요한 두 가지 주요 기능이 있으므로 약간의 인프라만 추가하면 서비스가 준비됩니다.

최종 단계

모든 작업을 수행하는 전처리 및 updateAgg 기능이 있습니다. 그러나 분 단위로 올바른 전환을 보장하고 집계를 위한 인덱스를 계산하는 것은 여전히 ​​필요합니다. 먼저 init 함수를 정의해 보겠습니다.

init:{
  tradeAgg:: 0#enlist[initWith]; // создаем пустую типизированную таблицу, enlist превращает словарь в таблицу, а 0# означает взять 0 элементов из нее
  currTime::00:00; // начнем с 0, :: означает, что присваивание в глобальную переменную
  currSyms::`u#`symbol$(); // `u# - превращает список в дерево, для ускорения поиска элементов
  offset::0; // индекс в tradeAgg, где начинается текущая минута 
  rollCache:: `sym xkey update `u#sym from rollColumns#tradeAgg; // кэш для последних значений roll колонок, таблица с ключом sym
 }

또한 현재 분을 변경하는 롤 함수를 정의합니다.

roll:{[tm]
  if[currTime>tm; :init[]]; // если перевалили за полночь, то просто вызовем init
  rollCache,::offset _ rollColumns#tradeAgg; // обновим кэш – взять roll колонки из aggTable, обрезать, вставить в rollCache
  offset::count tradeAgg;
  currSyms::`u#`$();
 }

새 문자를 추가하려면 다음과 같은 함수가 필요합니다.

addSyms:{[syms]
  currSyms,::syms; // добавим в список известных
  // добавим в таблицу sym, time и rollColumns воспользовавшись обобщенным присваиванием.
  // Функция ^ подставляет значения по умолчанию для roll колонок, если символа нет в кэше. value flip table возвращает список колонок в таблице.
  `tradeAgg upsert @[count[syms]#enlist initWith;`sym`time,cols rc;:;(syms;currTime), (initWith cols rc)^value flip rc:rollCache ([] sym: syms)];
 }

마지막으로 클라이언트가 데이터를 추가하기 위해 호출하는 upd 함수(Q 서비스에 대한 이 함수의 전통적인 이름)입니다.

upd:{[tblName;data] // tblName нам не нужно, но обычно сервис обрабатывает несколько таблиц 
  tm:exec distinct time from data:() xkey preprocess data; // preprocess & calc time
  updMinute[data] each tm; // добавим данные для каждой минуты
};
updMinute:{[data;tm]
  if[tm<>currTime; roll tm; currTime::tm]; // поменяем минуту, если необходимо
  data:select from data where time=tm; // фильтрация
  if[count msyms:syms where not (syms:data`sym)in currSyms; addSyms msyms]; // новые символы
  updateAgg[`tradeAgg;offset+currSyms?syms;data]; // обновим агрегированную таблицу. Функция ? ищет индекс элементов списка справа в списке слева.
 };

그게 다야. 약속한 대로 우리 서비스의 전체 코드는 다음과 같습니다. 몇 줄만 있으면 됩니다.

initWith:`sym`time`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover`avgPrice`avgSize`vwap`cumVolume!(`;00:00;0n;0n;0n;0n;0N;0N;0;0;0.0;0.0;0n;0n;0n;0);
aggCols:reverse key[initWith] except `sym`time;
rollColumns:`sym`cumVolume;

accumulatorCols:`numTrades`volume`pvolume`turnover;
specialCols:`high`low`firstPrice`firstSize;

selExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`numTrades`volume`pvolume`turnover!parse each ("max price";"min price";"first price";"last price";"first size";"last size";"count i";"sum size";"sum price";"sum price*size");
preprocess:?[;();`sym`time!`sym`time.minute;selExpression];

aggExpression:`high`low`firstPrice`lastPrice`firstSize`lastSize`avgPrice`avgSize`vwap`cumVolume!("row[`high]|inp`high";"row[`low]&inp`low";"row`firstPrice";"inp`lastPrice";"row`firstSize";"inp`lastSize";"pvolume%numTrades";"volume%numTrades";"turnover%volume";"row[`cumVolume]+inp`volume");
@[`aggExpression;specialCols;{"?[isFirst;inp`",y,";",x,"]"};string specialCols];
aggExpression[accumulatorCols]:{"row[`",x,"]+inp`",x } each string accumulatorCols;
updateAgg:value "{[aggTable;idx;inp] row:aggTable idx; isFirst_0=row`numTrades; .[aggTable;;:;]'[(idx;)each aggCols;(",(";"sv string[aggCols],'":",/:aggExpression aggCols),")]}"; / '

init:{
  tradeAgg::0#enlist[initWith];
  currTime::00:00;
  currSyms::`u#`symbol$();
  offset::0;
  rollCache:: `sym xkey update `u#sym from rollColumns#tradeAgg;
 };
roll:{[tm]
  if[currTime>tm; :init[]];
  rollCache,::offset _ rollColumns#tradeAgg;
  offset::count tradeAgg;
  currSyms::`u#`$();
 };
addSyms:{[syms]
  currSyms,::syms;
  `tradeAgg upsert @[count[syms]#enlist initWith;`sym`time,cols rc;:;(syms;currTime),(initWith cols rc)^value flip rc:rollCache ([] sym: syms)];
 };

upd:{[tblName;data] updMinute[data] each exec distinct time from data:() xkey preprocess data};
updMinute:{[data;tm]
  if[tm<>currTime; roll tm; currTime::tm];
  data:select from data where time=tm;
  if[count msyms:syms where not (syms:data`sym)in currSyms; addSyms msyms];
  updateAgg[`tradeAgg;offset+currSyms?syms;data];
 };

테스트

서비스 성능을 확인해 보겠습니다. 이를 위해 별도의 프로세스에서 실행하고(코드를 service.q 파일에 넣음) init 함수를 호출합니다.

q service.q –p 5566

q)init[]

다른 콘솔에서 두 번째 Q 프로세스를 시작하고 첫 번째 프로세스에 연결합니다.

h:hopen `:host:5566
h:hopen 5566 // если оба на одном хосте

먼저 기호 목록(10000개)을 만들고 임의 테이블을 만드는 함수를 추가해 보겠습니다. 두 번째 콘솔에서:

syms:`IBM`AAPL`GOOG,-9997?`8
rnd:{[n;t] ([] sym:n?syms; time:t+asc n#til 25; price:n?10f; size:n?10)}

테이블에서 더 쉽게 찾을 수 있도록 실제 기호 세 개를 목록에 추가했습니다. rnd 함수는 n개의 행이 있는 임의 테이블을 생성합니다. 여기서 시간은 t에서 t+25밀리초까지 다양합니다.

이제 서비스에 데이터 전송을 시도해 볼 수 있습니다(처음 XNUMX시간 추가).

{h (`upd;`trade;rnd[10000;x])} each `time$00:00 + til 60*10

테이블이 업데이트되었는지 서비스에서 확인할 수 있습니다.

c 25 200
select from tradeAgg where sym=`AAPL
-20#select from tradeAgg where sym=`AAPL

결과 :

sym|time|high|low|firstPrice|lastPrice|firstSize|lastSize|numTrades|volume|pvolume|turnover|avgPrice|avgSize|vwap|cumVolume
--|--|--|--|--|--------------------------------
AAPL|09:27|9.258904|9.258904|9.258904|9.258904|8|8|1|8|9.258904|74.07123|9.258904|8|9.258904|2888
AAPL|09:28|9.068162|9.068162|9.068162|9.068162|7|7|1|7|9.068162|63.47713|9.068162|7|9.068162|2895
AAPL|09:31|4.680449|0.2011121|1.620827|0.2011121|1|5|4|14|9.569556|36.84342|2.392389|3.5|2.631673|2909
AAPL|09:33|2.812535|2.812535|2.812535|2.812535|6|6|1|6|2.812535|16.87521|2.812535|6|2.812535|2915
AAPL|09:34|5.099025|5.099025|5.099025|5.099025|4|4|1|4|5.099025|20.3961|5.099025|4|5.099025|2919

이제 서비스가 분당 얼마나 많은 데이터를 처리할 수 있는지 알아보기 위해 로드 테스트를 수행해 보겠습니다. 업데이트 간격을 25밀리초로 설정했음을 상기시켜 드리겠습니다. 따라서 사용자에게 데이터를 요청할 시간을 제공하려면 서비스가 (평균적으로) 업데이트당 최소 20밀리초에 맞아야 합니다. 두 번째 프로세스에서는 다음을 입력합니다.

tm:10:00:00.000
stressTest:{[n] 1 string[tm]," "; times,::h ({st:.z.T; upd[`trade;x]; .z.T-st};rnd[n;tm]); tm+:25}
start:{[n] times::(); do[4800;stressTest[n]]; -1 " "; `min`avg`med`max!(min times;avg times;med times;max times)}

4800은 1000분입니다. 25밀리초마다 XNUMX개 행에 대해 먼저 실행해 볼 수 있습니다.

start 1000

제 경우 결과는 업데이트당 약 10.000밀리초 정도입니다. 따라서 즉시 행 수를 XNUMX개로 늘립니다.

start 10000

결과 :

min| 00:00:00.004
avg| 9.191458
med| 9f
max| 00:00:00.030

다시 말하지만 특별한 것은 아니지만 분당 24만 줄, 초당 400만 줄입니다. 25밀리초 이상 동안 업데이트 속도가 5번만 느려졌는데, 분 단위가 변경된 것으로 보입니다. 100.000으로 늘리자:

start 100000

결과 :

min| 00:00:00.013
avg| 25.11083
med| 24f
max| 00:00:00.108
q)sum times
00:02:00.532

보시다시피 서비스는 거의 대처할 수 없지만 그럼에도 불구하고 계속 유지됩니다. 이러한 데이터 볼륨(분당 240억 XNUMX천만 행)은 매우 크며, 이러한 경우 서비스의 여러 클론(심지어 수십 개의 클론)을 시작하는 것이 일반적이며 각 서비스는 문자의 일부만 처리합니다. 그럼에도 불구하고 주로 데이터 저장에 초점을 맞춘 해석 언어의 결과는 인상적입니다.

각 업데이트의 크기에 따라 시간이 비선형적으로 증가하는 이유에 대한 의문이 생길 수 있습니다. 그 이유는 축소 함수가 실제로는 updateAgg보다 훨씬 효율적인 C 함수이기 때문입니다. 특정 업데이트 크기(약 10.000)부터 updateAgg가 최대치에 도달하면 실행 시간은 업데이트 크기에 영향을 받지 않습니다. 서비스가 이러한 양의 데이터를 소화할 수 있는 것은 예비 단계 Q 때문입니다. 이는 빅데이터 작업 시 올바른 알고리즘을 선택하는 것이 얼마나 중요한지 강조합니다. 또 다른 요점은 메모리에 데이터를 올바르게 저장하는 것입니다. 데이터가 열 형식으로 저장되지 않거나 시간별로 정렬되지 않은 경우 TLB 캐시 미스(프로세서 주소 캐시에 메모리 페이지 주소가 없음)와 같은 현상에 익숙해질 것입니다. 주소 검색에 실패할 경우 약 30배 정도의 시간이 소요되며, 데이터가 흩어지면 서비스 속도가 몇 배로 느려질 수 있습니다.

결론

이번 글에서는 KDB+와 Q 데이터베이스가 대용량 데이터를 저장하고 select를 통해 쉽게 접근할 수 있을 뿐만 아니라, 수억 행/기가바이트 규모의 데이터를 소화할 수 있는 데이터 처리 서비스를 만드는 데에도 적합하다는 점을 보여주었다. 하나의 단일 Q 프로세스. Q 언어 자체는 벡터 특성, 내장된 SQL 언어 해석기 및 매우 성공적인 라이브러리 기능 세트로 인해 데이터 처리와 관련된 알고리즘을 매우 간결하고 효율적으로 구현할 수 있습니다.

위의 내용은 Q가 수행할 수 있는 작업의 일부일 뿐이며 다른 고유한 기능도 있다는 점에 유의하겠습니다. 예를 들어, 개별 Q 프로세스 사이의 경계를 지우고 수백 개의 프로세스를 단일 네트워크로 결합할 수 있는 매우 간단한 IPC 프로토콜은 전 세계 여러 지역에 있는 수십 개의 서버에 위치할 수 있습니다.

출처 : habr.com