thevar1able/ClickHouse
1
0
Fork 0
mirror of https://github.com/ClickHouse/ClickHouse.git synced 2024-11-30 19:42:00 +00:00
Code Issues Packages Projects Releases Wiki Activity
47dbe9e628
ClickHouse/docs/tr/sql-reference/aggregate-functions/reference.md
Ivan Blinkov cd14f9ebcb
SQL reference refactoring (#10857) 
* split up select.md

* array-join.md basic refactoring

* distinct.md basic refactoring

* format.md basic refactoring

* from.md basic refactoring

* group-by.md basic refactoring

* having.md basic refactoring

* additional index.md refactoring

* into-outfile.md basic refactoring

* join.md basic refactoring

* limit.md basic refactoring

* limit-by.md basic refactoring

* order-by.md basic refactoring

* prewhere.md basic refactoring

* adjust operators/index.md links

* adjust sample.md links

* adjust more links

* adjust operatots links

* fix some links

* adjust aggregate function article titles

* basic refactor of remaining select clauses

* absolute paths in make_links.sh

* run make_links.sh

* remove old select.md locations

* translate docs/es

* translate docs/fr

* translate docs/fa

* remove old operators.md location

* change operators.md links

* adjust links in docs/es

* adjust links in docs/es

* minor texts adjustments

* wip

* update machine translations to use new links

* fix changelog

* es build fixes

* get rid of some select.md links

* temporary adjust ru links

* temporary adjust more ru links

* improve curly brace handling

* adjust ru as well

* fa build fix

* ru link fixes

* zh link fixes

* temporary disable part of anchor checks
2020-05-15 07:34:54 +03:00

1978 lines
68 KiB
Markdown
Raw Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

---
machine_translated: true
machine_translated_rev: 72537a2d527c63c07aa5d2361a8829f3895cf2bd
toc_priority: 36
toc_title: "Ba\u015Fvurma"
---
# Toplama Fonksiyonu Referansı {#aggregate-functions-reference}
## sayma {#agg_function-count}
Satır veya NOT-NULL değerleri sayar.
ClickHouse için aşağıdaki sözdizimleri destekler `count`:
- `count(expr)` veya `COUNT(DISTINCT expr)`.
- `count()` veya `COUNT(*)`. Bu `count()` sözdizimi ClickHouse özeldir.
**Parametre**
Fonksiyon alabilir:
- Sıfır parametreler.
- Bir [ifade](../syntax.md#syntax-expressions).
**Döndürülen değer**
- Fonksiyon parametreleri olmadan çağrılırsa, satır sayısını sayar.
- Eğer... [ifade](../syntax.md#syntax-expressions) geçirilir, daha sonra işlev bu ifadenin kaç kez NOT null döndürdüğünü sayar. İfad aede bir [Nullable](../../sql-reference/data-types/nullable.md)- type değeri, sonra sonucu `count` kalır değil `Nullable`. İfade döndürülürse işlev 0 döndürür `NULL` tüm satırlar için.
Her iki durumda da döndürülen değerin türü [Uİnt64](../../sql-reference/data-types/int-uint.md).
**Ayrıntı**
ClickHouse destekler `COUNT(DISTINCT ...)` sözdizimi. Bu yapının davranışı Aşağıdakilere bağlıdır [count\_distinct\_implementation](../../operations/settings/settings.md#settings-count_distinct_implementation) ayar. Aşağıdakilerden hang theisini tanımlar [uniq\*](#agg_function-uniq) fonksiyonlar işlemi gerçekleştirmek için kullanılır. Varsayılan değer [uniqExact](#agg_function-uniqexact) İşlev.
Bu `SELECT count() FROM table` tablodaki girdi sayısı ayrı olarak depolanmadığı için sorgu en iyi duruma getirilmez. Tablodan küçük bir sütun seçer ve içindeki değerlerin sayısını sayar.
**Örnekler**
Örnek 1:
``` sql
SELECT count() FROM t
```
``` text
┌─count()─┐
│ 5 │
└─────────┘
```
Örnek 2:
``` sql
SELECT name, value FROM system.settings WHERE name = 'count_distinct_implementation'
```
``` text
┌─name──────────────────────────┬─value─────┐
│ count_distinct_implementation │ uniqExact │
└───────────────────────────────┴───────────┘
```
``` sql
SELECT count(DISTINCT num) FROM t
```
``` text
┌─uniqExact(num)─┐
│ 3 │
└────────────────┘
```
Bu örnek gösteriyor ki `count(DISTINCT num)` tarafından gerçekleştirilir `uniqExact` fonksiyonu göre `count_distinct_implementation` ayar değeri.
## herhangi(x) {#agg_function-any}
İlk karşılaşılan değeri seçer.
Sorgu herhangi bir sırada ve hatta her seferinde farklı bir sırada çalıştırılabilir, bu nedenle bu işlevin sonucu belirsizdir.
Belirli bir sonuç elde etmek için ‘min’ veya ‘max’ fonksiyon yerine ‘any’.
Bazı durumlarda, yürütme sırasına güvenebilirsiniz. Bu, select ORDER BY kullanan bir alt sorgudan geldiğinde durumlar için geçerlidir.
Ne zaman bir `SELECT` sorgu vardır `GROUP BY` yan tümce veya en az bir toplama işlevi, ClickHouse (Mysql'in aksine), tüm ifadelerin `SELECT`, `HAVING`, ve `ORDER BY` anahtar functionslardan veya toplama işlev .lerinden hesaplan .malıdır. Başka bir deyişle, tablodan seçilen her sütun, anahtarlarda veya toplama işlevlerinde kullanılmalıdır. Mysql'de olduğu gibi davranış elde etmek için, diğer sütunları `any` toplama işlevi.
## anyHeavy (x) {#anyheavyx}
Kullanarak sık oluşan bir değer seçer [ağır vurucular](http://www.cs.umd.edu/~samir/498/karp.pdf) algoritma. Sorgunun yürütme iş parçacığı her durumda yarısından fazlasını oluşan bir değer varsa, bu değer döndürülür. Normalde, sonuç belirsizdir.
``` sql
anyHeavy(column)
```
**Değişkenler**
- `column` – The column name.
**Örnek**
Tak thee the [OnTime](../../getting-started/example-datasets/ontime.md) veri kümesi ve herhangi bir sık oluşan değeri seçin `AirlineID` sütun.
``` sql
SELECT anyHeavy(AirlineID) AS res
FROM ontime
```
``` text
┌───res─┐
│ 19690 │
└───────┘
```
## anyLast(x) {#anylastx}
Karşılaşılan son değeri seçer.
Sonuç için olduğu kadar belirsiz `any` İşlev.
## groupBitAnd {#groupbitand}
Bitwise uygular `AND` sayı serisi için.
``` sql
groupBitAnd(expr)
```
**Parametre**
`expr` – An expression that results in `UInt*` tür.
**Dönüş değeri**
Bu değer `UInt*` tür.
**Örnek**
Test verileri:
``` text
binary decimal
00101100 = 44
00011100 = 28
00001101 = 13
01010101 = 85
```
Sorgu:
``` sql
SELECT groupBitAnd(num) FROM t
```
Nerede `num` test verileri ile sütundur.
Sonuç:
``` text
binary decimal
00000100 = 4
```
## groupBitOr {#groupbitor}
Bitwise uygular `OR` sayı serisi için.
``` sql
groupBitOr(expr)
```
**Parametre**
`expr` – An expression that results in `UInt*` tür.
**Dönüş değeri**
Bu değer `UInt*` tür.
**Örnek**
Test verileri:
``` text
binary decimal
00101100 = 44
00011100 = 28
00001101 = 13
01010101 = 85
```
Sorgu:
``` sql
SELECT groupBitOr(num) FROM t
```
Nerede `num` test verileri ile sütundur.
Sonuç:
``` text
binary decimal
01111101 = 125
```
## groupBitXor {#groupbitxor}
Bitwise uygular `XOR` sayı serisi için.
``` sql
groupBitXor(expr)
```
**Parametre**
`expr` – An expression that results in `UInt*` tür.
**Dönüş değeri**
Bu değer `UInt*` tür.
**Örnek**
Test verileri:
``` text
binary decimal
00101100 = 44
00011100 = 28
00001101 = 13
01010101 = 85
```
Sorgu:
``` sql
SELECT groupBitXor(num) FROM t
```
Nerede `num` test verileri ile sütundur.
Sonuç:
``` text
binary decimal
01101000 = 104
```
## groupBitmap {#groupbitmap}
İşaretsiz tamsayı sütun, Uınt64 tür iade önem, gelen bit eşlem veya Toplama hesaplamaları suffix ekleme -Devlet, sonra iade [bitmap nesnesi](../../sql-reference/functions/bitmap-functions.md).
``` sql
groupBitmap(expr)
```
**Parametre**
`expr` – An expression that results in `UInt*` tür.
**Dönüş değeri**
Bu değer `UInt64` tür.
**Örnek**
Test verileri:
``` text
UserID
1
1
2
3
```
Sorgu:
``` sql
SELECT groupBitmap(UserID) as num FROM t
```
Sonuç:
``` text
num
3
```
## min (x) {#agg_function-min}
Minimum hesaplar.
## max (x) {#agg_function-max}
Maksimum hesaplar.
## argMin (arg, val) {#agg-function-argmin}
Hesaplar ‘arg’ minimum değer ‘val’ değer. Birkaç farklı değer varsa ‘arg’ minimum değerler için ‘val’, karşılaşılan bu değerlerin ilki çıktıdır.
**Örnek:**
``` text
┌─user─────┬─salary─┐
│ director │ 5000 │
│ manager │ 3000 │
│ worker │ 1000 │
└──────────┴────────┘
```
``` sql
SELECT argMin(user, salary) FROM salary
```
``` text
┌─argMin(user, salary)─┐
│ worker │
└──────────────────────┘
```
## argMax (arg, val) {#agg-function-argmax}
Hesaplar ‘arg’ maksimum değer ‘val’ değer. Birkaç farklı değer varsa ‘arg’ maksimum değerler için ‘val’, karşılaşılan bu değerlerin ilki çıktıdır.
## s (um (x) {#agg_function-sum}
Toplamı hesaplar.
Sadece sayılar için çalışır.
## sumWithOverflow(x) {#sumwithoverflowx}
Giriş parametreleri için olduğu gibi sonuç için aynı veri türünü kullanarak sayıların toplamını hesaplar. Toplam bu veri türü için en büyük değeri aşarsa, işlev bir hata döndürür.
Sadece sayılar için çalışır.
## sumMap (anahtar, değer), sumMap(Tuple (anahtar, değer)) {#agg_functions-summap}
Toplam thelar ‘value’ belirtilen tuş accordinglara göre dizi ‘key’ dizi.
Anahtarları ve değerleri diziler dizi geçen anahtarları ve değerleri iki dizi geçen synonymical var.
Eleman sayısı ‘key’ ve ‘value’ toplam her satır için aynı olmalıdır.
Returns a tuple of two arrays: keys in sorted order, and values ​​summed for the corresponding keys.
Örnek:
``` sql
CREATE TABLE sum_map(
date Date,
timeslot DateTime,
statusMap Nested(
status UInt16,
requests UInt64
),
statusMapTuple Tuple(Array(Int32), Array(Int32))
) ENGINE = Log;
INSERT INTO sum_map VALUES
('2000-01-01', '2000-01-01 00:00:00', [1, 2, 3], [10, 10, 10], ([1, 2, 3], [10, 10, 10])),
('2000-01-01', '2000-01-01 00:00:00', [3, 4, 5], [10, 10, 10], ([3, 4, 5], [10, 10, 10])),
('2000-01-01', '2000-01-01 00:01:00', [4, 5, 6], [10, 10, 10], ([4, 5, 6], [10, 10, 10])),
('2000-01-01', '2000-01-01 00:01:00', [6, 7, 8], [10, 10, 10], ([6, 7, 8], [10, 10, 10]));
SELECT
timeslot,
sumMap(statusMap.status, statusMap.requests),
sumMap(statusMapTuple)
FROM sum_map
GROUP BY timeslot
```
``` text
┌────────────timeslot─┬─sumMap(statusMap.status, statusMap.requests)─┬─sumMap(statusMapTuple)─────────┐
│ 2000-01-01 00:00:00 │ ([1,2,3,4,5],[10,10,20,10,10]) │ ([1,2,3,4,5],[10,10,20,10,10]) │
│ 2000-01-01 00:01:00 │ ([4,5,6,7,8],[10,10,20,10,10]) │ ([4,5,6,7,8],[10,10,20,10,10]) │
└─────────────────────┴──────────────────────────────────────────────┴────────────────────────────────┘
```
## skewPop {#skewpop}
Hesaplar [çarpıklık](https://en.wikipedia.org/wiki/Skewness) bir sıra.
``` sql
skewPop(expr)
```
**Parametre**
`expr` — [İfade](../syntax.md#syntax-expressions) bir numara döndürüyor.
**Döndürülen değer**
The skewness of the given distribution. Type — [Float64](../../sql-reference/data-types/float.md)
**Örnek**
``` sql
SELECT skewPop(value) FROM series_with_value_column
```
## skewSamp {#skewsamp}
Hesaplar [örnek çarpıklık](https://en.wikipedia.org/wiki/Skewness) bir sıra.
Bir rassal değişkenin çarpıklığının tarafsız bir tahminini temsil eder.
``` sql
skewSamp(expr)
```
**Parametre**
`expr` — [İfade](../syntax.md#syntax-expressions) bir numara döndürüyor.
**Döndürülen değer**
The skewness of the given distribution. Type — [Float64](../../sql-reference/data-types/float.md). Eğer `n <= 1` (`n` örnek boyutudur), daha sonra işlev döner `nan`.
**Örnek**
``` sql
SELECT skewSamp(value) FROM series_with_value_column
```
## kurtPop {#kurtpop}
Hesaplar [kurtosis](https://en.wikipedia.org/wiki/Kurtosis) bir sıra.
``` sql
kurtPop(expr)
```
**Parametre**
`expr` — [İfade](../syntax.md#syntax-expressions) bir numara döndürüyor.
**Döndürülen değer**
The kurtosis of the given distribution. Type — [Float64](../../sql-reference/data-types/float.md)
**Örnek**
``` sql
SELECT kurtPop(value) FROM series_with_value_column
```
## kurtSamp {#kurtsamp}
Hesaplar [örnek kurtoz](https://en.wikipedia.org/wiki/Kurtosis) bir sıra.
Eğer geçen değerleri örnek oluşturur, eğer bir rassal değişken kurtosis tarafsız bir tahmini temsil eder.
``` sql
kurtSamp(expr)
```
**Parametre**
`expr` — [İfade](../syntax.md#syntax-expressions) bir numara döndürüyor.
**Döndürülen değer**
The kurtosis of the given distribution. Type — [Float64](../../sql-reference/data-types/float.md). Eğer `n <= 1` (`n` örnek bir boyutudur), daha sonra işlev döner `nan`.
**Örnek**
``` sql
SELECT kurtSamp(value) FROM series_with_value_column
```
## timeSeriesGroupSum(uıd, zaman damgası, değer) {#agg-function-timeseriesgroupsum}
`timeSeriesGroupSum` örnek zaman damgası değil hizalama farklı zaman serileri toplayabilir.
İki örnek zaman damgası arasında doğrusal enterpolasyon kullanacak ve daha sonra zaman serilerini birlikte toplayacaktır.
- `uid` zaman serisi benzersiz kimliği mi, `UInt64`.
- `timestamp` milisaniye veya mikrosaniye desteklemek için Int64 türüdür.
- `value` metr .iktir.
İşlev, tuples dizisini döndürür `(timestamp, aggregated_value)` çiftliler.
Bu işlevi kullanmadan önce emin olun `timestamp` artan düzende.
Örnek:
``` text
┌─uid─┬─timestamp─┬─value─┐
│ 1 │ 2 │ 0.2 │
│ 1 │ 7 │ 0.7 │
│ 1 │ 12 │ 1.2 │
│ 1 │ 17 │ 1.7 │
│ 1 │ 25 │ 2.5 │
│ 2 │ 3 │ 0.6 │
│ 2 │ 8 │ 1.6 │
│ 2 │ 12 │ 2.4 │
│ 2 │ 18 │ 3.6 │
│ 2 │ 24 │ 4.8 │
└─────┴───────────┴───────┘
```
``` sql
CREATE TABLE time_series(
uid UInt64,
timestamp Int64,
value Float64
) ENGINE = Memory;
INSERT INTO time_series VALUES
(1,2,0.2),(1,7,0.7),(1,12,1.2),(1,17,1.7),(1,25,2.5),
(2,3,0.6),(2,8,1.6),(2,12,2.4),(2,18,3.6),(2,24,4.8);
SELECT timeSeriesGroupSum(uid, timestamp, value)
FROM (
SELECT * FROM time_series order by timestamp ASC
);
```
Ve sonuç olacak:
``` text
[(2,0.2),(3,0.9),(7,2.1),(8,2.4),(12,3.6),(17,5.1),(18,5.4),(24,7.2),(25,2.5)]
```
## timeSeriesGroupRateSum(uıd, ts, val) {#agg-function-timeseriesgroupratesum}
Benzer şekilde `timeSeriesGroupSum`, `timeSeriesGroupRateSum` zaman serilerinin oranını hesaplar ve daha sonra toplam oranları birlikte hesaplar.
Ayrıca, bu işlevi kullanmadan önce zaman damgası yükseliş sırasına göre olmalıdır.
Bu fonksiyon dataun ver theiye uygulanması `timeSeriesGroupSum` örnek, aşağıdaki sonucu alırsınız:
``` text
[(2,0),(3,0.1),(7,0.3),(8,0.3),(12,0.3),(17,0.3),(18,0.3),(24,0.3),(25,0.1)]
```
## avg (x) {#agg_function-avg}
Ortalama hesaplar.
Sadece sayılar için çalışır.
Sonuç Her zaman Float64.
## avgWeighted {#avgweighted}
Hesaplar [ağırlıklı aritmetik ortalama](https://en.wikipedia.org/wiki/Weighted_arithmetic_mean).
**Sözdizimi**
``` sql
avgWeighted(x, weight)
```
**Parametre**
- `x` — Values. [Tamsayı](../data-types/int-uint.md) veya [kayan nokta](../data-types/float.md).
- `weight` — Weights of the values. [Tamsayı](../data-types/int-uint.md) veya [kayan nokta](../data-types/float.md).
Türü `x` ve `weight` aynı olmalıdır.
**Döndürülen değer**
- Ağırlıklı ortalama.
- `NaN`. Tüm ağırlıklar 0'a eşitse.
Tür: [Float64](../data-types/float.md).
**Örnek**
Sorgu:
``` sql
SELECT avgWeighted(x, w)
FROM values('x Int8, w Int8', (4, 1), (1, 0), (10, 2))
```
Sonuç:
``` text
┌─avgWeighted(x, weight)─┐
│ 8 │
└────────────────────────┘
```
## uniq {#agg_function-uniq}
Bağımsız değişken farklı değerlerin yaklaşık sayısını hesaplar.
``` sql
uniq(x[, ...])
```
**Parametre**
Fonksiyon değişken sayıda parametre alır. Parametreler olabilir `Tuple`, `Array`, `Date`, `DateTime`, `String` veya sayısal türleri.
**Döndürülen değer**
- A [Uİnt64](../../sql-reference/data-types/int-uint.md)- tip numarası.
**Uygulama Detayları**
İşlev:
- Toplamdaki tüm parametreler için bir karma hesaplar, daha sonra hesaplamalarda kullanır.
- Bir adaptif örnekleme algoritması kullanır. Hesaplama durumu için işlev, 65536'ya kadar öğe karma değerlerinin bir örneğini kullanır.
This algorithm is very accurate and very efficient on the CPU. When the query contains several of these functions, using `uniq` is almost as fast as using other aggregate functions.
- Sonucu deterministically sağlar (sorgu işleme sırasına bağlı değildir).
Bu işlevi hemen hemen tüm senaryolarda kullanmanızı öneririz.
**Ayrıca Bakınız**
- [uniqCombined](#agg_function-uniqcombined)
- [uniqCombined64](#agg_function-uniqcombined64)
- [uniqHLL12](#agg_function-uniqhll12)
- [uniqExact](#agg_function-uniqexact)
## uniqCombined {#agg_function-uniqcombined}
Farklı bağımsız değişken değerlerinin yaklaşık sayısını hesaplar.
``` sql
uniqCombined(HLL_precision)(x[, ...])
```
Bu `uniqCombined` fonksiyon, farklı değerlerin sayısını hesaplamak için iyi bir seçimdir.
**Parametre**
Fonksiyon değişken sayıda parametre alır. Parametreler olabilir `Tuple`, `Array`, `Date`, `DateTime`, `String` veya sayısal türleri.
`HLL_precision` hücre sayısının baz-2 logaritmasıdır. [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog). İsteğe bağlı olarak işlevi kullanabilirsiniz `uniqCombined(x[, ...])`. İçin varsayılan değer `HLL_precision` etkin bir şekilde 96 KiB alan olan 17'dir (2^17 hücre, her biri 6 bit).
**Döndürülen değer**
- Numara [Uİnt64](../../sql-reference/data-types/int-uint.md)- tip numarası.
**Uygulama Detayları**
İşlev:
- Bir karma hesaplar (64-bit karma için `String` ve 32-bit aksi halde) agregadaki tüm parametreler için, hesaplamalarda kullanır.
- Bir hata düzeltme tablosu ile dizi, karma tablo ve HyperLogLog: üç algoritmaları bir arada kullanır.
For a small number of distinct elements, an array is used. When the set size is larger, a hash table is used. For a larger number of elements, HyperLogLog is used, which will occupy a fixed amount of memory.
- Sonucu deterministically sağlar (sorgu işleme sırasına bağlı değildir).
!!! note "Not"
Olmayan için 32-bit karma kullandığından-`String` tipi, sonuç cardinalities önemli ölçüde daha büyük için çok yüksek hata olacak `UINT_MAX` (birkaç on milyarlarca farklı değerden sonra hata hızla artacaktır), bu durumda kullanmanız gerekir [uniqCombined64](#agg_function-uniqcombined64)
İle karşılaştırıldığında [uniq](#agg_function-uniq) fonksiyonu, `uniqCombined`:
- Birkaç kez daha az bellek tüketir.
- Birkaç kat daha yüksek doğrulukla hesaplar.
- Genellikle biraz daha düşük performansa sahiptir. Bazı senaryolarda, `uniqCombined` daha iyi performans gösterebilir `uniq` örneğin, ağ üzerinden çok sayıda toplama durumu ileten dağıtılmış sorgularla.
**Ayrıca Bakınız**
- [uniq](#agg_function-uniq)
- [uniqCombined64](#agg_function-uniqcombined64)
- [uniqHLL12](#agg_function-uniqhll12)
- [uniqExact](#agg_function-uniqexact)
## uniqCombined64 {#agg_function-uniqcombined64}
Aynı olarak [uniqCombined](#agg_function-uniqcombined), ancak tüm veri türleri için 64 bit karma kullanır.
## uniqHLL12 {#agg_function-uniqhll12}
Farklı argüman değerlerinin yaklaşık sayısını hesaplar [HyperLogLog](https://en.wikipedia.org/wiki/HyperLogLog) algoritma.
``` sql
uniqHLL12(x[, ...])
```
**Parametre**
Fonksiyon değişken sayıda parametre alır. Parametreler olabilir `Tuple`, `Array`, `Date`, `DateTime`, `String` veya sayısal türleri.
**Döndürülen değer**
- A [Uİnt64](../../sql-reference/data-types/int-uint.md)- tip numarası.
**Uygulama Detayları**
İşlev:
- Toplamdaki tüm parametreler için bir karma hesaplar, daha sonra hesaplamalarda kullanır.
- Farklı bağımsız değişken değerlerinin sayısını yaklaştırmak için HyperLogLog algoritmasını kullanır.
212 5-bit cells are used. The size of the state is slightly more than 2.5 KB. The result is not very accurate (up to ~10% error) for small data sets (<10K elements). However, the result is fairly accurate for high-cardinality data sets (10K-100M), with a maximum error of ~1.6%. Starting from 100M, the estimation error increases, and the function will return very inaccurate results for data sets with extremely high cardinality (1B+ elements).
- Belirli sonucu sağlar (sorgu işleme sırasına bağlı değildir).
Bu işlevi kullanmanızı önermiyoruz. Çoğu durumda, kullan [uniq](#agg_function-uniq) veya [uniqCombined](#agg_function-uniqcombined) İşlev.
**Ayrıca Bakınız**
- [uniq](#agg_function-uniq)
- [uniqCombined](#agg_function-uniqcombined)
- [uniqExact](#agg_function-uniqexact)
## uniqExact {#agg_function-uniqexact}
Farklı bağımsız değişken değerlerinin tam sayısını hesaplar.
``` sql
uniqExact(x[, ...])
```
Kullan... `uniqExact` kesinlikle kesin bir sonuca ihtiyacınız varsa işlev. Aksi takdirde kullanın [uniq](#agg_function-uniq) İşlev.
Bu `uniqExact` fonksiyonu daha fazla bellek kullanır `uniq`, çünkü farklı değerlerin sayısı arttıkça devletin büyüklüğü sınırsız büyümeye sahiptir.
**Parametre**
Fonksiyon değişken sayıda parametre alır. Parametreler olabilir `Tuple`, `Array`, `Date`, `DateTime`, `String` veya sayısal türleri.
**Ayrıca Bakınız**
- [uniq](#agg_function-uniq)
- [uniqCombined](#agg_function-uniqcombined)
- [uniqHLL12](#agg_function-uniqhll12)
## groupArray (x), groupArray (max\_size)(x) {#agg_function-grouparray}
Bağımsız değişken değerleri dizisi oluşturur.
Değerler diziye herhangi bir (belirsiz) sırayla eklenebilir.
İkinci versiyonu (ile `max_size` parametre), elde edilen dizinin boyutunu sınırlar `max_size` öğeler.
Mesela, `groupArray (1) (x)` eşdeğ toer equivalentdir `[any (x)]`.
Bazı durumlarda, hala yürütme sırasına güvenebilirsiniz. Bu, aşağıdaki durumlar için geçerlidir `SELECT` kullanan bir alt sorgudan gelir `ORDER BY`.
## grouparrayınsertat {#grouparrayinsertat}
Belirtilen konumda diziye bir değer ekler.
**Sözdizimi**
``` sql
groupArrayInsertAt(default_x, size)(x, pos);
```
Bir sorguda aynı konuma birkaç değer eklenirse, işlev aşağıdaki şekillerde davranır:
- Bir sorgu tek bir iş parçacığında yürütülürse, eklenen değerlerden ilki kullanılır.
- Bir sorgu birden çok iş parçacığında yürütülürse, ortaya çıkan değer, eklenen değerlerden belirsiz bir değerdir.
**Parametre**
- `x` — Value to be inserted. [İfade](../syntax.md#syntax-expressions) biri sonuçta [desteklenen veri türleri](../../sql-reference/data-types/index.md).
- `pos` — Position at which the specified element `x` eklen .ecektir. Dizideki dizin numaralandırma sıfırdan başlar. [Uİnt32](../../sql-reference/data-types/int-uint.md#uint-ranges).
- `default_x`— Default value for substituting in empty positions. Optional parameter. [İfade](../syntax.md#syntax-expressions) için yapılandırılmış veri türü ile sonuçlanan `x` parametre. Eğer `default_x` tanımlan ,mamıştır, [varsayılan değerler](../../sql-reference/statements/create.md#create-default-values) kullanılır.
- `size`— Length of the resulting array. Optional parameter. When using this parameter, the default value `default_x` belirt .ilmelidir. [Uİnt32](../../sql-reference/data-types/int-uint.md#uint-ranges).
**Döndürülen değer**
- Eklenen değerlerle dizi.
Tür: [Dizi](../../sql-reference/data-types/array.md#data-type-array).
**Örnek**
Sorgu:
``` sql
SELECT groupArrayInsertAt(toString(number), number * 2) FROM numbers(5);
```
Sonuç:
``` text
┌─groupArrayInsertAt(toString(number), multiply(number, 2))─┐
│ ['0','','1','','2','','3','','4'] │
└───────────────────────────────────────────────────────────┘
```
Sorgu:
``` sql
SELECT groupArrayInsertAt('-')(toString(number), number * 2) FROM numbers(5);
```
Sonuç:
``` text
┌─groupArrayInsertAt('-')(toString(number), multiply(number, 2))─┐
│ ['0','-','1','-','2','-','3','-','4'] │
└────────────────────────────────────────────────────────────────┘
```
Sorgu:
``` sql
SELECT groupArrayInsertAt('-', 5)(toString(number), number * 2) FROM numbers(5);
```
Sonuç:
``` text
┌─groupArrayInsertAt('-', 5)(toString(number), multiply(number, 2))─┐
│ ['0','-','1','-','2'] │
└───────────────────────────────────────────────────────────────────┘
```
Elemanların tek bir konuma çok dişli yerleştirilmesi.
Sorgu:
``` sql
SELECT groupArrayInsertAt(number, 0) FROM numbers_mt(10) SETTINGS max_block_size = 1;
```
Bu sorgu sonucunda rastgele tamsayı elde edersiniz `[0,9]` Aralık. Mesela:
``` text
┌─groupArrayInsertAt(number, 0)─┐
│ [7] │
└───────────────────────────────┘
```
## groupArrayMovingSum {#agg_function-grouparraymovingsum}
Giriş değerlerinin hareketli toplamını hesaplar.
``` sql
groupArrayMovingSum(numbers_for_summing)
groupArrayMovingSum(window_size)(numbers_for_summing)
```
İşlev, pencere boyutunu bir parametre olarak alabilir. Belirtilmemiş bırakılırsa, işlev, sütundaki satır sayısına eşit pencere boyutunu alır.
**Parametre**
- `numbers_for_summing` — [İfade](../syntax.md#syntax-expressions) sayısal veri türü değeri ile sonuçlanır.
- `window_size` — Size of the calculation window.
**Döndürülen değerler**
- Giriş verileri ile aynı boyut ve türdeki dizi.
**Örnek**
Örnek tablo:
``` sql
CREATE TABLE t
(
`int` UInt8,
`float` Float32,
`dec` Decimal32(2)
)
ENGINE = TinyLog
```
``` text
┌─int─┬─float─┬──dec─┐
│ 1 │ 1.1 │ 1.10 │
│ 2 │ 2.2 │ 2.20 │
│ 4 │ 4.4 │ 4.40 │
│ 7 │ 7.77 │ 7.77 │
└─────┴───────┴──────┘
```
Sorgu:
``` sql
SELECT
groupArrayMovingSum(int) AS I,
groupArrayMovingSum(float) AS F,
groupArrayMovingSum(dec) AS D
FROM t
```
``` text
┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
│ [1,3,7,14] │ [1.1,3.3000002,7.7000003,15.47] │ [1.10,3.30,7.70,15.47] │
└────────────┴─────────────────────────────────┴────────────────────────┘
```
``` sql
SELECT
groupArrayMovingSum(2)(int) AS I,
groupArrayMovingSum(2)(float) AS F,
groupArrayMovingSum(2)(dec) AS D
FROM t
```
``` text
┌─I──────────┬─F───────────────────────────────┬─D──────────────────────┐
│ [1,3,6,11] │ [1.1,3.3000002,6.6000004,12.17] │ [1.10,3.30,6.60,12.17] │
└────────────┴─────────────────────────────────┴────────────────────────┘
```
## groupArrayMovingAvg {#agg_function-grouparraymovingavg}
Giriş değerlerinin hareketli ortalamasını hesaplar.
``` sql
groupArrayMovingAvg(numbers_for_summing)
groupArrayMovingAvg(window_size)(numbers_for_summing)
```
İşlev, pencere boyutunu bir parametre olarak alabilir. Belirtilmemiş bırakılırsa, işlev, sütundaki satır sayısına eşit pencere boyutunu alır.
**Parametre**
- `numbers_for_summing` — [İfade](../syntax.md#syntax-expressions) sayısal veri türü değeri ile sonuçlanır.
- `window_size` — Size of the calculation window.
**Döndürülen değerler**
- Giriş verileri ile aynı boyut ve türdeki dizi.
İşlev kullanır [sıfıra doğru yuvarlama](https://en.wikipedia.org/wiki/Rounding#Rounding_towards_zero). Sonuç veri türü için önemsiz ondalık basamaklar keser.
**Örnek**
Örnek tablo `b`:
``` sql
CREATE TABLE t
(
`int` UInt8,
`float` Float32,
`dec` Decimal32(2)
)
ENGINE = TinyLog
```
``` text
┌─int─┬─float─┬──dec─┐
│ 1 │ 1.1 │ 1.10 │
│ 2 │ 2.2 │ 2.20 │
│ 4 │ 4.4 │ 4.40 │
│ 7 │ 7.77 │ 7.77 │
└─────┴───────┴──────┘
```
Sorgu:
``` sql
SELECT
groupArrayMovingAvg(int) AS I,
groupArrayMovingAvg(float) AS F,
groupArrayMovingAvg(dec) AS D
FROM t
```
``` text
┌─I─────────┬─F───────────────────────────────────┬─D─────────────────────┐
│ [0,0,1,3] │ [0.275,0.82500005,1.9250001,3.8675] │ [0.27,0.82,1.92,3.86] │
└───────────┴─────────────────────────────────────┴───────────────────────┘
```
``` sql
SELECT
groupArrayMovingAvg(2)(int) AS I,
groupArrayMovingAvg(2)(float) AS F,
groupArrayMovingAvg(2)(dec) AS D
FROM t
```
``` text
┌─I─────────┬─F────────────────────────────────┬─D─────────────────────┐
│ [0,1,3,5] │ [0.55,1.6500001,3.3000002,6.085] │ [0.55,1.65,3.30,6.08] │
└───────────┴──────────────────────────────────┴───────────────────────┘
```
## groupUniqArray (x), groupUniqArray (max\_size)(x) {#groupuniqarrayx-groupuniqarraymax-sizex}
Farklı bağımsız değişken değerlerinden bir dizi oluşturur. Bellek tüketimi için aynıdır `uniqExact` İşlev.
İkinci versiyonu (ile `max_size` parametre), elde edilen dizinin boyutunu sınırlar `max_size` öğeler.
Mesela, `groupUniqArray(1)(x)` eşdeğ toer equivalentdir `[any(x)]`.
## quantile {#quantile}
Yaklaşık hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) sayısal veri dizisinin.
Bu işlev geçerlidir [rezerv reservoiruar örnek samplinglemesi](https://en.wikipedia.org/wiki/Reservoir_sampling) 8192'ye kadar bir rezervuar boyutu ve örnekleme için rastgele sayı üreteci ile. Sonuç deterministik değildir. Tam bir miktar elde etmek için [quantileExact](#quantileexact) İşlev.
Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) İşlev.
**Sözdizimi**
``` sql
quantile(level)(expr)
```
Takma ad: `median`.
**Parametre**
- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median).
- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql-reference/data-types/index.md#data_types), [Tarihli](../../sql-reference/data-types/date.md) veya [DateTime](../../sql-reference/data-types/datetime.md).
**Döndürülen değer**
- Belirtilen seviyenin yaklaşık miktarı.
Tür:
- [Float64](../../sql-reference/data-types/float.md) sayısal veri türü girişi için.
- [Tarihli](../../sql-reference/data-types/date.md) giriş değerleri varsa `Date` tür.
- [DateTime](../../sql-reference/data-types/datetime.md) giriş değerleri varsa `DateTime` tür.
**Örnek**
Giriş tablosu:
``` text
┌─val─┐
│ 1 │
│ 1 │
│ 2 │
│ 3 │
└─────┘
```
Sorgu:
``` sql
SELECT quantile(val) FROM t
```
Sonuç:
``` text
┌─quantile(val)─┐
│ 1.5 │
└───────────────┘
```
**Ayrıca Bakınız**
- [medyan](#median)
- [quantiles](#quantiles)
## quantileDeterministic {#quantiledeterministic}
Yaklaşık hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) sayısal veri dizisinin.
Bu işlev geçerlidir [rezerv reservoiruar örnek samplinglemesi](https://en.wikipedia.org/wiki/Reservoir_sampling) 8192'ye kadar bir rezervuar boyutu ve örnekleme deterministik algoritması ile. Sonuç deterministiktir. Tam bir miktar elde etmek için [quantileExact](#quantileexact) İşlev.
Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) İşlev.
**Sözdizimi**
``` sql
quantileDeterministic(level)(expr, determinator)
```
Takma ad: `medianDeterministic`.
**Parametre**
- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median).
- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql-reference/data-types/index.md#data_types), [Tarihli](../../sql-reference/data-types/date.md) veya [DateTime](../../sql-reference/data-types/datetime.md).
- `determinator` — Number whose hash is used instead of a random number generator in the reservoir sampling algorithm to make the result of sampling deterministic. As a determinator you can use any deterministic positive number, for example, a user id or an event id. If the same determinator value occures too often, the function works incorrectly.
**Döndürülen değer**
- Belirtilen seviyenin yaklaşık miktarı.
Tür:
- [Float64](../../sql-reference/data-types/float.md) sayısal veri türü girişi için.
- [Tarihli](../../sql-reference/data-types/date.md) giriş değerleri varsa `Date` tür.
- [DateTime](../../sql-reference/data-types/datetime.md) giriş değerleri varsa `DateTime` tür.
**Örnek**
Giriş tablosu:
``` text
┌─val─┐
│ 1 │
│ 1 │
│ 2 │
│ 3 │
└─────┘
```
Sorgu:
``` sql
SELECT quantileDeterministic(val, 1) FROM t
```
Sonuç:
``` text
┌─quantileDeterministic(val, 1)─┐
│ 1.5 │
└───────────────────────────────┘
```
**Ayrıca Bakınız**
- [medyan](#median)
- [quantiles](#quantiles)
## quantileExact {#quantileexact}
Tam olarak hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) sayısal veri dizisinin.
To get exact value, all the passed values ​​are combined into an array, which is then partially sorted. Therefore, the function consumes `O(n)` bellek, nerede `n` geçirilen değerler say .ısıdır. Bununla birlikte, az sayıda değer için, işlev çok etkilidir.
Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) İşlev.
**Sözdizimi**
``` sql
quantileExact(level)(expr)
```
Takma ad: `medianExact`.
**Parametre**
- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median).
- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql-reference/data-types/index.md#data_types), [Tarihli](../../sql-reference/data-types/date.md) veya [DateTime](../../sql-reference/data-types/datetime.md).
**Döndürülen değer**
- Belirtilen seviyenin miktarı.
Tür:
- [Float64](../../sql-reference/data-types/float.md) sayısal veri türü girişi için.
- [Tarihli](../../sql-reference/data-types/date.md) giriş değerleri varsa `Date` tür.
- [DateTime](../../sql-reference/data-types/datetime.md) giriş değerleri varsa `DateTime` tür.
**Örnek**
Sorgu:
``` sql
SELECT quantileExact(number) FROM numbers(10)
```
Sonuç:
``` text
┌─quantileExact(number)─┐
│ 5 │
└───────────────────────┘
```
**Ayrıca Bakınız**
- [medyan](#median)
- [quantiles](#quantiles)
## quantilexactweighted {#quantileexactweighted}
Tam olarak hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) her elemanın ağırlığını dikkate alarak sayısal bir veri dizisinin.
To get exact value, all the passed values ​​are combined into an array, which is then partially sorted. Each value is counted with its weight, as if it is present `weight` times. A hash table is used in the algorithm. Because of this, if the passed values ​​are frequently repeated, the function consumes less RAM than [quantileExact](#quantileexact). Bunun yerine bu işlevi kullanabilirsiniz `quantileExact` ve 1 ağırlığını belirtin.
Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) İşlev.
**Sözdizimi**
``` sql
quantileExactWeighted(level)(expr, weight)
```
Takma ad: `medianExactWeighted`.
**Parametre**
- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median).
- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql-reference/data-types/index.md#data_types), [Tarihli](../../sql-reference/data-types/date.md) veya [DateTime](../../sql-reference/data-types/datetime.md).
- `weight` — Column with weights of sequence members. Weight is a number of value occurrences.
**Döndürülen değer**
- Belirtilen seviyenin miktarı.
Tür:
- [Float64](../../sql-reference/data-types/float.md) sayısal veri türü girişi için.
- [Tarihli](../../sql-reference/data-types/date.md) giriş değerleri varsa `Date` tür.
- [DateTime](../../sql-reference/data-types/datetime.md) giriş değerleri varsa `DateTime` tür.
**Örnek**
Giriş tablosu:
``` text
┌─n─┬─val─┐
│ 0 │ 3 │
│ 1 │ 2 │
│ 2 │ 1 │
│ 5 │ 4 │
└───┴─────┘
```
Sorgu:
``` sql
SELECT quantileExactWeighted(n, val) FROM t
```
Sonuç:
``` text
┌─quantileExactWeighted(n, val)─┐
│ 1 │
└───────────────────────────────┘
```
**Ayrıca Bakınız**
- [medyan](#median)
- [quantiles](#quantiles)
## quantileTiming {#quantiletiming}
Belirlenen hassas hesaplar ile [quantile](https://en.wikipedia.org/wiki/Quantile) sayısal veri dizisinin.
Sonuç deterministiktir (sorgu işleme sırasına bağlı değildir). Fonksiyon yükleme web sayfaları kez veya arka uç yanıt süreleri gibi dağılımları tanımlamak dizileri ile çalışmak için optimize edilmiştir.
Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) İşlev.
**Sözdizimi**
``` sql
quantileTiming(level)(expr)
```
Takma ad: `medianTiming`.
**Parametre**
- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median).
- `expr` — [İfade](../syntax.md#syntax-expressions) bir sütun değerleri üzerinde dönen bir [Yüzdürmek\*](../../sql-reference/data-types/float.md)- tip numarası.
- If negative values are passed to the function, the behavior is undefined.
- If the value is greater than 30,000 (a page loading time of more than 30 seconds), it is assumed to be 30,000.
**Doğruluk**
Hesaplama doğru ise:
- Toplam değer sayısı 5670'i geçmez.
- Toplam değer sayısı 5670'i aşıyor, ancak sayfa yükleme süresi 1024 ms'den az.
Aksi takdirde, hesaplamanın sonucu 16 MS'nin en yakın katlarına yuvarlanır.
!!! note "Not"
Sayfa yükleme süresi nicelerini hesaplamak için, bu işlev daha etkili ve doğrudur [quantile](#quantile).
**Döndürülen değer**
- Belirtilen seviyenin miktarı.
Tür: `Float32`.
!!! note "Not"
İşlev valuese hiçbir değer geçir (ilmem (işse (kullanırken `quantileTimingIf`), [Nine](../../sql-reference/data-types/float.md#data_type-float-nan-inf) döndürülür. Bunun amacı, bu vakaları sıfır ile sonuçlanan vakalardan ayırmaktır. Görmek [ORDER BY FLA BYGE](../statements/select/order-by.md#select-order-by) sıralama ile ilgili notlar için `NaN` değerler.
**Örnek**
Giriş tablosu:
``` text
┌─response_time─┐
│ 72 │
│ 112 │
│ 126 │
│ 145 │
│ 104 │
│ 242 │
│ 313 │
│ 168 │
│ 108 │
└───────────────┘
```
Sorgu:
``` sql
SELECT quantileTiming(response_time) FROM t
```
Sonuç:
``` text
┌─quantileTiming(response_time)─┐
│ 126 │
└───────────────────────────────┘
```
**Ayrıca Bakınız**
- [medyan](#median)
- [quantiles](#quantiles)
## niceletimingweighted {#quantiletimingweighted}
Belirlenen hassas hesaplar ile [quantile](https://en.wikipedia.org/wiki/Quantile) her sıra üyesi ağırlığına göre sayısal veri dizisi.
Sonuç deterministiktir (sorgu işleme sırasına bağlı değildir). Fonksiyon yükleme web sayfaları kez veya arka uç yanıt süreleri gibi dağılımları tanımlamak dizileri ile çalışmak için optimize edilmiştir.
Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) İşlev.
**Sözdizimi**
``` sql
quantileTimingWeighted(level)(expr, weight)
```
Takma ad: `medianTimingWeighted`.
**Parametre**
- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median).
- `expr` — [İfade](../syntax.md#syntax-expressions) bir sütun değerleri üzerinde dönen bir [Yüzdürmek\*](../../sql-reference/data-types/float.md)- tip numarası.
- If negative values are passed to the function, the behavior is undefined.
- If the value is greater than 30,000 (a page loading time of more than 30 seconds), it is assumed to be 30,000.
- `weight` — Column with weights of sequence elements. Weight is a number of value occurrences.
**Doğruluk**
Hesaplama doğru ise:
- Toplam değer sayısı 5670'i geçmez.
- Toplam değer sayısı 5670'i aşıyor, ancak sayfa yükleme süresi 1024 ms'den az.
Aksi takdirde, hesaplamanın sonucu 16 MS'nin en yakın katlarına yuvarlanır.
!!! note "Not"
Sayfa yükleme süresi nicelerini hesaplamak için, bu işlev daha etkili ve doğrudur [quantile](#quantile).
**Döndürülen değer**
- Belirtilen seviyenin miktarı.
Tür: `Float32`.
!!! note "Not"
İşlev valuese hiçbir değer geçir (ilmem (işse (kullanırken `quantileTimingIf`), [Nine](../../sql-reference/data-types/float.md#data_type-float-nan-inf) döndürülür. Bunun amacı, bu vakaları sıfır ile sonuçlanan vakalardan ayırmaktır. Görmek [ORDER BY FLA BYGE](../statements/select/order-by.md#select-order-by) sıralama ile ilgili notlar için `NaN` değerler.
**Örnek**
Giriş tablosu:
``` text
┌─response_time─┬─weight─┐
│ 68 │ 1 │
│ 104 │ 2 │
│ 112 │ 3 │
│ 126 │ 2 │
│ 138 │ 1 │
│ 162 │ 1 │
└───────────────┴────────┘
```
Sorgu:
``` sql
SELECT quantileTimingWeighted(response_time, weight) FROM t
```
Sonuç:
``` text
┌─quantileTimingWeighted(response_time, weight)─┐
│ 112 │
└───────────────────────────────────────────────┘
```
**Ayrıca Bakınız**
- [medyan](#median)
- [quantiles](#quantiles)
## quantileTDigest {#quantiletdigest}
Yaklaşık hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) kullanarak sayısal veri diz ofisinin [t-dig -est](https://github.com/tdunning/t-digest/blob/master/docs/t-digest-paper/histo.pdf) algoritma.
Maksimum hata %1'dir. Bellek tüketimi `log(n)`, nere `n` değer say isısıdır. Sonuç, sorguyu çalıştırma sırasına bağlıdır ve nondeterministic.
Fonksiyonun performansı, performanstan daha düşüktür [quantile](#quantile) veya [quantileTiming](#quantiletiming). Durum boyutunun hassasiyete oranı açısından, bu işlev çok daha iyidir `quantile`.
Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) İşlev.
**Sözdizimi**
``` sql
quantileTDigest(level)(expr)
```
Takma ad: `medianTDigest`.
**Parametre**
- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median).
- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql-reference/data-types/index.md#data_types), [Tarihli](../../sql-reference/data-types/date.md) veya [DateTime](../../sql-reference/data-types/datetime.md).
**Döndürülen değer**
- Belirtilen seviyenin yaklaşık miktarı.
Tür:
- [Float64](../../sql-reference/data-types/float.md) sayısal veri türü girişi için.
- [Tarihli](../../sql-reference/data-types/date.md) giriş değerleri varsa `Date` tür.
- [DateTime](../../sql-reference/data-types/datetime.md) giriş değerleri varsa `DateTime` tür.
**Örnek**
Sorgu:
``` sql
SELECT quantileTDigest(number) FROM numbers(10)
```
Sonuç:
``` text
┌─quantileTDigest(number)─┐
│ 4.5 │
└─────────────────────────┘
```
**Ayrıca Bakınız**
- [medyan](#median)
- [quantiles](#quantiles)
## quantileTDigestWeighted {#quantiletdigestweighted}
Yaklaşık hesaplar [quantile](https://en.wikipedia.org/wiki/Quantile) kullanarak sayısal veri diz ofisinin [t-dig -est](https://github.com/tdunning/t-digest/blob/master/docs/t-digest-paper/histo.pdf) algoritma. İşlev, her sıra üyesinin ağırlığını dikkate alır. Maksimum hata %1'dir. Bellek tüketimi `log(n)`, nere `n` değer say isısıdır.
Fonksiyonun performansı, performanstan daha düşüktür [quantile](#quantile) veya [quantileTiming](#quantiletiming). Durum boyutunun hassasiyete oranı açısından, bu işlev çok daha iyidir `quantile`.
Sonuç, sorguyu çalıştırma sırasına bağlıdır ve nondeterministic.
Çoklu kullanırken `quantile*` bir sorguda farklı düzeylerde işlevler, iç durumları birleştirilmez (diğer bir deyişle, sorgu olabilir daha az verimli çalışır). Bu durumda, kullan [quantiles](#quantiles) İşlev.
**Sözdizimi**
``` sql
quantileTDigest(level)(expr)
```
Takma ad: `medianTDigest`.
**Parametre**
- `level` — Level of quantile. Optional parameter. Constant floating-point number from 0 to 1. We recommend using a `level` aralığında değer `[0.01, 0.99]`. Varsayılan değer: 0.5. Yanında `level=0.5` fonksiyon hesaplar [medyan](https://en.wikipedia.org/wiki/Median).
- `expr` — Expression over the column values resulting in numeric [veri türleri](../../sql-reference/data-types/index.md#data_types), [Tarihli](../../sql-reference/data-types/date.md) veya [DateTime](../../sql-reference/data-types/datetime.md).
- `weight` — Column with weights of sequence elements. Weight is a number of value occurrences.
**Döndürülen değer**
- Belirtilen seviyenin yaklaşık miktarı.
Tür:
- [Float64](../../sql-reference/data-types/float.md) sayısal veri türü girişi için.
- [Tarihli](../../sql-reference/data-types/date.md) giriş değerleri varsa `Date` tür.
- [DateTime](../../sql-reference/data-types/datetime.md) giriş değerleri varsa `DateTime` tür.
**Örnek**
Sorgu:
``` sql
SELECT quantileTDigestWeighted(number, 1) FROM numbers(10)
```
Sonuç:
``` text
┌─quantileTDigestWeighted(number, 1)─┐
│ 4.5 │
└────────────────────────────────────┘
```
**Ayrıca Bakınız**
- [medyan](#median)
- [quantiles](#quantiles)
## medyan {#median}
Bu `median*` fonksiyonlar karşılık gelen takma adlardır `quantile*` işlevler. Sayısal bir veri örneğinin medyanını hesaplarlar.
İşlevler:
- `median` — Alias for [quantile](#quantile).
- `medianDeterministic` — Alias for [quantileDeterministic](#quantiledeterministic).
- `medianExact` — Alias for [quantileExact](#quantileexact).
- `medianExactWeighted` — Alias for [quantilexactweighted](#quantileexactweighted).
- `medianTiming` — Alias for [quantileTiming](#quantiletiming).
- `medianTimingWeighted` — Alias for [niceletimingweighted](#quantiletimingweighted).
- `medianTDigest` — Alias for [quantileTDigest](#quantiletdigest).
- `medianTDigestWeighted` — Alias for [quantileTDigestWeighted](#quantiletdigestweighted).
**Örnek**
Giriş tablosu:
``` text
┌─val─┐
│ 1 │
│ 1 │
│ 2 │
│ 3 │
└─────┘
```
Sorgu:
``` sql
SELECT medianDeterministic(val, 1) FROM t
```
Sonuç:
``` text
┌─medianDeterministic(val, 1)─┐
│ 1.5 │
└─────────────────────────────┘
```
## quantiles(level1, level2, …)(x) {#quantiles}
Tüm quantile fonksiyonları da karşılık gelen quantile fonksiyonlarına sahiptir: `quantiles`, `quantilesDeterministic`, `quantilesTiming`, `quantilesTimingWeighted`, `quantilesExact`, `quantilesExactWeighted`, `quantilesTDigest`. Bu işlevler, listelenen seviyelerin tüm nicelerini tek geçişte hesaplar ve elde edilen değerlerin bir dizisini döndürür.
## varSamp (x) {#varsampx}
Miktarı hesaplar `Σ((x - x̅)^2) / (n - 1)`, nere `n` örneklem büyüklüğü ve `x̅`ortalama değer isidir `x`.
Bir rassal değişkenin varyansının tarafsız bir tahminini temsil eder, eğer geçirilen değerler numunesini oluşturursa.
Dönüşler `Float64`. Ne zaman `n <= 1`, dönüşler `+∞`.
!!! note "Not"
Bu işlev sayısal olarak kararsız algoritma kullanır. İhtiyacınız varsa [sayısal kararlılık](https://en.wikipedia.org/wiki/Numerical_stability) hesaplamalarda kullan `varSampStable` İşlev. Daha yavaş çalışır, ancak daha düşük hesaplama hatası sağlar.
## varPop (x) {#varpopx}
Miktarı hesaplar `Σ((x - x̅)^2) / n`, nere `n` örneklem büyüklüğü ve `x̅`ortalama değer isidir `x`.
Başka bir deyişle, bir dizi değer için dağılım. Dönüşler `Float64`.
!!! note "Not"
Bu işlev sayısal olarak kararsız algoritma kullanır. İhtiyacınız varsa [sayısal kararlılık](https://en.wikipedia.org/wiki/Numerical_stability) hesaplamalarda kullan `varPopStable` İşlev. Daha yavaş çalışır, ancak daha düşük hesaplama hatası sağlar.
## stddevSamp(x) {#stddevsampx}
Sonuç kareköküne eşittir `varSamp(x)`.
!!! note "Not"
Bu işlev sayısal olarak kararsız algoritma kullanır. İhtiyacınız varsa [sayısal kararlılık](https://en.wikipedia.org/wiki/Numerical_stability) hesaplamalarda kullan `stddevSampStable` İşlev. Daha yavaş çalışır, ancak daha düşük hesaplama hatası sağlar.
## stddevPop(x) {#stddevpopx}
Sonuç kareköküne eşittir `varPop(x)`.
!!! note "Not"
Bu işlev sayısal olarak kararsız algoritma kullanır. İhtiyacınız varsa [sayısal kararlılık](https://en.wikipedia.org/wiki/Numerical_stability) hesaplamalarda kullan `stddevPopStable` İşlev. Daha yavaş çalışır, ancak daha düşük hesaplama hatası sağlar.
## topK (N) (x) {#topknx}
Belirtilen sütundaki yaklaşık en sık değerleri bir dizi döndürür. Elde edilen dizi, değerlerin yaklaşık frekansının azalan sırasına göre sıralanır (değerlerin kendileri tarafından değil).
Uygular [Filtrelenmiş Yerden Tasarruf](http://www.l2f.inesc-id.pt/~fmmb/wiki/uploads/Work/misnis.ref0a.pdf) TopK analiz etmek için algoritma, azaltmak ve birleştirmek algoritması dayalı [Paralel Alan Tasarrufu](https://arxiv.org/pdf/1401.0702.pdf).
``` sql
topK(N)(column)
```
Bu işlev garantili bir sonuç sağlamaz. Bazı durumlarda, hatalar oluşabilir ve en sık kullanılan değerler olmayan sık değerler döndürebilir.
Biz kullanmanızı öneririz `N < 10` değer; performans büyük ile azalır `N` değerler. Maksimum değeri `N = 65536`.
**Parametre**
- ‘N’ dönmek için Öğe sayısıdır.
Parametre atlanırsa, varsayılan değer 10 kullanılır.
**Değişkenler**
- ' x ' – The value to calculate frequency.
**Örnek**
Tak thee the [OnTime](../../getting-started/example-datasets/ontime.md) veri kümesi ve üç en sık oluşan değerleri seçin `AirlineID` sütun.
``` sql
SELECT topK(3)(AirlineID) AS res
FROM ontime
```
``` text
┌─res─────────────────┐
│ [19393,19790,19805] │
└─────────────────────┘
```
## topKWeighted {#topkweighted}
Benzer `topK` ancak tamsayı türünde bir ek argüman alır - `weight`. Her değer muhasebeleştirilir `weight` frekans hesaplaması için zamanlar.
**Sözdizimi**
``` sql
topKWeighted(N)(x, weight)
```
**Parametre**
- `N` — The number of elements to return.
**Değişkenler**
- `x` – The value.
- `weight` — The weight. [Uİnt8](../../sql-reference/data-types/int-uint.md).
**Döndürülen değer**
Maksimum yaklaşık ağırlık toplamına sahip değerlerin bir dizisini döndürür.
**Örnek**
Sorgu:
``` sql
SELECT topKWeighted(10)(number, number) FROM numbers(1000)
```
Sonuç:
``` text
┌─topKWeighted(10)(number, number)──────────┐
│ [999,998,997,996,995,994,993,992,991,990] │
└───────────────────────────────────────────┘
```
## covarSamp(x, y) {#covarsampx-y}
Değerini hesaplar `Σ((x - x̅)(y - y̅)) / (n - 1)`.
Float64 Döndürür. Ne zaman `n <= 1`, returns +∞.
!!! note "Not"
Bu işlev sayısal olarak kararsız algoritma kullanır. İhtiyacınız varsa [sayısal kararlılık](https://en.wikipedia.org/wiki/Numerical_stability) hesaplamalarda kullan `covarSampStable` İşlev. Daha yavaş çalışır, ancak daha düşük hesaplama hatası sağlar.
## covarPop (x, y) {#covarpopx-y}
Değerini hesaplar `Σ((x - x̅)(y - y̅)) / n`.
!!! note "Not"
Bu işlev sayısal olarak kararsız algoritma kullanır. İhtiyacınız varsa [sayısal kararlılık](https://en.wikipedia.org/wiki/Numerical_stability) hesaplamalarda kullan `covarPopStable` İşlev. Daha yavaş çalışır, ancak daha düşük bir hesaplama hatası sağlar.
## corr(x, y) {#corrx-y}
Pearson korelasyon katsayısını hesaplar: `Σ((x - x̅)(y - y̅)) / sqrt(Σ((x - x̅)^2) * Σ((y - y̅)^2))`.
!!! note "Not"
Bu işlev sayısal olarak kararsız algoritma kullanır. İhtiyacınız varsa [sayısal kararlılık](https://en.wikipedia.org/wiki/Numerical_stability) hesaplamalarda kullan `corrStable` İşlev. Daha yavaş çalışır, ancak daha düşük hesaplama hatası sağlar.
## categoricalınformationvalue {#categoricalinformationvalue}
Değerini hesaplar `(P(tag = 1) - P(tag = 0))(log(P(tag = 1)) - log(P(tag = 0)))` her kategori için.
``` sql
categoricalInformationValue(category1, category2, ..., tag)
```
Sonuç, ayrık (kategorik) bir özelliğin nasıl olduğunu gösterir `[category1, category2, ...]` değerini öngör aen bir öğrenme modeline katkıda `tag`.
## simpleLinearRegression {#simplelinearregression}
Basit (tek boyutlu) doğrusal regresyon gerçekleştirir.
``` sql
simpleLinearRegression(x, y)
```
Parametre:
- `x` — Column with dependent variable values.
- `y` — Column with explanatory variable values.
Döndürülen değerler:
Devamlılar `(a, b)` ortaya çıkan hat linetın `y = a*x + b`.
**Örnekler**
``` sql
SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])
```
``` text
┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [0, 1, 2, 3])─┐
│ (1,0) │
└───────────────────────────────────────────────────────────────────┘
```
``` sql
SELECT arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])
```
``` text
┌─arrayReduce('simpleLinearRegression', [0, 1, 2, 3], [3, 4, 5, 6])─┐
│ (1,3) │
└───────────────────────────────────────────────────────────────────┘
```
## stokastiklinearregression {#agg_functions-stochasticlinearregression}
Bu fonksiyon stokastik doğrusal regresyon uygular. Öğrenme oranı, L2 regularization katsayısı, mini-batch boyutu için özel parametreleri destekler ve ağırlıkları güncellemek için birkaç yöntem vardır ([Adem](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Adam) (varsayılan olarak kullanılır), [basit SGD](https://en.wikipedia.org/wiki/Stochastic_gradient_descent), [İvme](https://en.wikipedia.org/wiki/Stochastic_gradient_descent#Momentum), [Nesterov](https://mipt.ru/upload/medialibrary/d7e/41-91.pdf)).
### Parametre {#agg_functions-stochasticlinearregression-parameters}
4 özelleştirilebilir parametre vardır. Onlar sırayla işleve geçirilir, ancak dört varsayılan değerleri kullanılacak geçmek gerek yoktur, ancak iyi bir model bazı parametre ayarlama gerekli.
``` text
stochasticLinearRegression(1.0, 1.0, 10, 'SGD')
```
1. `learning rate` Gradyan iniş adımı gerçekleştirildiğinde adım uzunluğundaki katsayıdır. Çok büyük öğrenme oranı, modelin sonsuz ağırlıklarına neden olabilir. Default is `0.00001`.
2. `l2 regularization coefficient` hangi overfitting önlemek için yardımcı olabilir. Default is `0.1`.
3. `mini-batch size` gradyanların hesaplanacağı ve Gradyan inişinin bir adımını gerçekleştirmek için toplanacağı öğelerin sayısını ayarlar. Saf stokastik iniş bir eleman kullanır, ancak küçük partilere(yaklaşık 10 eleman) sahip olmak degrade adımları daha kararlı hale getirir. Default is `15`.
4. `method for updating weights` onlar : `Adam` (varsayılan olarak), `SGD`, `Momentum`, `Nesterov`. `Momentum` ve `Nesterov` biraz daha fazla hesaplama ve bellek gerektirir, ancak stokastik Gradyan yöntemlerinin yakınsama hızı ve kararlılığı açısından yararlı olurlar.
### Kullanma {#agg_functions-stochasticlinearregression-usage}
`stochasticLinearRegression` iki adımda kullanılır: modelin takılması ve yeni verilerin tahmin edilmesi. Modeli sığdırmak ve daha sonra kullanım için durumunu kaydetmek için kullandığımız `-State` temel olarak durumu kurtaran birleştirici (model ağırlıkları, vb.).
Fonksiyonu kullan wedığımızı tahmin etmek [evalMLMethod](../functions/machine-learning-functions.md#machine_learning_methods-evalmlmethod), bir argüman olarak bir durumu yanı sıra tahmin etmek için özellikler alır.
<a name="stochasticlinearregression-usage-fitting"></a>
**1.** Uydurma
Böyle bir sorgu kullanılabilir.
``` sql
CREATE TABLE IF NOT EXISTS train_data
(
param1 Float64,
param2 Float64,
target Float64
) ENGINE = Memory;
CREATE TABLE your_model ENGINE = Memory AS SELECT
stochasticLinearRegressionState(0.1, 0.0, 5, 'SGD')(target, param1, param2)
AS state FROM train_data;
```
Burada ayrıca veri eklememiz gerekiyor `train_data` Tablo. Parametrelerin sayısı sabit değildir, sadece argümanların sayısına bağlıdır, `linearRegressionState`. Hepsi sayısal değerler olmalıdır.
Hedef değere sahip sütunun(tahmin etmeyi öğrenmek istediğimiz) ilk argüman olarak eklendiğini unutmayın.
**2.** Öngören
Bir durumu tabloya kaydettikten sonra, tahmin için birden çok kez kullanabilir, hatta diğer durumlarla birleşebilir ve yeni daha iyi modeller oluşturabiliriz.
``` sql
WITH (SELECT state FROM your_model) AS model SELECT
evalMLMethod(model, param1, param2) FROM test_data
```
Sorgu, tahmin edilen değerlerin bir sütununu döndürür. Not ilk argüman `evalMLMethod` oluyor `AggregateFunctionState` nesne, sonraki özelliklerin sütunlarıdır.
`test_data` bir tablo gibi mi `train_data` ancak hedef değer içermeyebilir.
### Not {#agg_functions-stochasticlinearregression-notes}
1. İki modeli birleştirmek için Kullanıcı böyle bir sorgu oluşturabilir:
`sql SELECT state1 + state2 FROM your_models`
nerede `your_models` tablo her iki modeli de içerir. Bu sorgu yeni dönecektir `AggregateFunctionState` nesne.
2. Kullanıcı, modeli kaydetmeden oluşturulan modelin ağırlıklarını kendi amaçları için alabilir `-State` birleştirici kullanılır.
`sql SELECT stochasticLinearRegression(0.01)(target, param1, param2) FROM train_data`
Bu sorgu modele uyacak ve ağırlıklarını geri getirecektir-ilk önce modelin parametrelerine karşılık gelen ağırlıklar, sonuncusu önyargıdır. Yani yukarıdaki örnekte sorgu 3 değer içeren bir sütun döndürecektir.
**Ayrıca Bakınız**
- [stochasticLogisticRegression](#agg_functions-stochasticlogisticregression)
- [Doğrusal ve lojistik regresyonlar arasındaki fark](https://stackoverflow.com/questions/12146914/what-is-the-difference-between-linear-regression-and-logistic-regression)
## stochasticLogisticRegression {#agg_functions-stochasticlogisticregression}
Bu işlev stokastik lojistik regresyon uygular. İkili sınıflandırma problemi için kullanılabilir, stochasticLinearRegression ile aynı özel parametreleri destekler ve aynı şekilde çalışır.
### Parametre {#agg_functions-stochasticlogisticregression-parameters}
Parametreler tam olarak stochasticLinearRegression ile aynıdır:
`learning rate`, `l2 regularization coefficient`, `mini-batch size`, `method for updating weights`.
Daha fazla bilgi için bkz. [parametre](#agg_functions-stochasticlinearregression-parameters).
``` text
stochasticLogisticRegression(1.0, 1.0, 10, 'SGD')
```
1. Uydurma
<!-- -->
See the `Fitting` section in the [stochasticLinearRegression](#stochasticlinearregression-usage-fitting) description.
Predicted labels have to be in \[-1, 1\].
1. Öngören
<!-- -->
Using saved state we can predict probability of object having label `1`.
``` sql
WITH (SELECT state FROM your_model) AS model SELECT
evalMLMethod(model, param1, param2) FROM test_data
```
The query will return a column of probabilities. Note that first argument of `evalMLMethod` is `AggregateFunctionState` object, next are columns of features.
We can also set a bound of probability, which assigns elements to different labels.
``` sql
SELECT ans < 1.1 AND ans > 0.5 FROM
(WITH (SELECT state FROM your_model) AS model SELECT
evalMLMethod(model, param1, param2) AS ans FROM test_data)
```
Then the result will be labels.
`test_data` is a table like `train_data` but may not contain target value.
**Ayrıca Bakınız**
- [stokastiklinearregression](#agg_functions-stochasticlinearregression)
- [Doğrusal ve lojistik regresyonlar arasındaki fark.](https://stackoverflow.com/questions/12146914/what-is-the-difference-between-linear-regression-and-logistic-regression)
## groupBitmapAnd {#groupbitmapand}
Bu VE bir bitmap sütun, Uınt64 tür iade önem, hesaplamaları suffix ekleme -Devlet, sonra iade [bitmap nesnesi](../../sql-reference/functions/bitmap-functions.md).
``` sql
groupBitmapAnd(expr)
```
**Parametre**
`expr` – An expression that results in `AggregateFunction(groupBitmap, UInt*)` tür.
**Dönüş değeri**
Bu değer `UInt64` tür.
**Örnek**
``` sql
DROP TABLE IF EXISTS bitmap_column_expr_test2;
CREATE TABLE bitmap_column_expr_test2
(
tag_id String,
z AggregateFunction(groupBitmap, UInt32)
)
ENGINE = MergeTree
ORDER BY tag_id;
INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32))));
SELECT groupBitmapAnd(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─groupBitmapAnd(z)─┐
│ 3 │
└───────────────────┘
SELECT arraySort(bitmapToArray(groupBitmapAndState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─arraySort(bitmapToArray(groupBitmapAndState(z)))─┐
│ [6,8,10] │
└──────────────────────────────────────────────────┘
```
## groupBitmapOr {#groupbitmapor}
YA da bir bitmap sütun, Uınt64 tür iade önem, hesaplamaları suffix ekleme -Devlet, sonra iade [bitmap nesnesi](../../sql-reference/functions/bitmap-functions.md). Bu eşdeğerdir `groupBitmapMerge`.
``` sql
groupBitmapOr(expr)
```
**Parametre**
`expr` – An expression that results in `AggregateFunction(groupBitmap, UInt*)` tür.
**Dönüş değeri**
Bu değer `UInt64` tür.
**Örnek**
``` sql
DROP TABLE IF EXISTS bitmap_column_expr_test2;
CREATE TABLE bitmap_column_expr_test2
(
tag_id String,
z AggregateFunction(groupBitmap, UInt32)
)
ENGINE = MergeTree
ORDER BY tag_id;
INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32))));
SELECT groupBitmapOr(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─groupBitmapOr(z)─┐
│ 15 │
└──────────────────┘
SELECT arraySort(bitmapToArray(groupBitmapOrState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─arraySort(bitmapToArray(groupBitmapOrState(z)))─┐
│ [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15] │
└─────────────────────────────────────────────────┘
```
## groupBitmapXor {#groupbitmapxor}
Bir bitmap sütun, Uınt64 tür iade önem hesaplamaları XOR, suffix ekleme -Devlet, sonra iade [bitmap nesnesi](../../sql-reference/functions/bitmap-functions.md).
``` sql
groupBitmapOr(expr)
```
**Parametre**
`expr` – An expression that results in `AggregateFunction(groupBitmap, UInt*)` tür.
**Dönüş değeri**
Bu değer `UInt64` tür.
**Örnek**
``` sql
DROP TABLE IF EXISTS bitmap_column_expr_test2;
CREATE TABLE bitmap_column_expr_test2
(
tag_id String,
z AggregateFunction(groupBitmap, UInt32)
)
ENGINE = MergeTree
ORDER BY tag_id;
INSERT INTO bitmap_column_expr_test2 VALUES ('tag1', bitmapBuild(cast([1,2,3,4,5,6,7,8,9,10] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag2', bitmapBuild(cast([6,7,8,9,10,11,12,13,14,15] as Array(UInt32))));
INSERT INTO bitmap_column_expr_test2 VALUES ('tag3', bitmapBuild(cast([2,4,6,8,10,12] as Array(UInt32))));
SELECT groupBitmapXor(z) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─groupBitmapXor(z)─┐
│ 10 │
└───────────────────┘
SELECT arraySort(bitmapToArray(groupBitmapXorState(z))) FROM bitmap_column_expr_test2 WHERE like(tag_id, 'tag%');
┌─arraySort(bitmapToArray(groupBitmapXorState(z)))─┐
│ [1,3,5,6,8,10,11,13,14,15] │
└──────────────────────────────────────────────────┘
```
[Orijinal makale](https://clickhouse.tech/docs/en/query_language/agg_functions/reference/) <!--hide-->
Reference in New Issue View Git Blame Copy Permalink