ClickHouse/docs/tr/sql-reference/functions/string-functions.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

490 lines
14 KiB
Markdown
Raw Blame History

This file contains ambiguous Unicode characters

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: 40
toc_title: "Dizeleri ile \xE7al\u0131\u015Fma"
---
# Dizelerle çalışmak için işlevler {#functions-for-working-with-strings}
## boş {#empty}
Boş bir dize için 1 veya boş olmayan bir dize için 0 döndürür.
Sonuç türü Uint8'dir.
Bir boşluk veya boş bayt olsa bile, en az bir bayt içeriyorsa, bir dize boş olarak kabul edilir.
İşlev ayrıca diziler için de çalışır.
## notEmpty {#notempty}
Boş bir dize için 0 veya boş olmayan bir dize için 1 döndürür.
Sonuç türü Uint8'dir.
İşlev ayrıca diziler için de çalışır.
## uzunluk {#length}
Bir dizenin uzunluğunu bayt cinsinden döndürür (karakterlerde değil, kod noktalarında değil).
Sonuç türü Uint64'tür.
İşlev ayrıca diziler için de çalışır.
## lengthUTF8 {#lengthutf8}
Dizenin UTF-8 kodlanmış metni oluşturan bir bayt kümesi içerdiğini varsayarak, Unicode kod noktalarında (karakterlerde değil) bir dizenin uzunluğunu döndürür. Bu varsayım karşılanmazsa, bir sonuç döndürür (bir istisna atmaz).
Sonuç türü Uint64'tür.
## char\_length, CHAR\_LENGTH {#char-length}
Dizenin UTF-8 kodlanmış metni oluşturan bir bayt kümesi içerdiğini varsayarak, Unicode kod noktalarında (karakterlerde değil) bir dizenin uzunluğunu döndürür. Bu varsayım karşılanmazsa, bir sonuç döndürür (bir istisna atmaz).
Sonuç türü Uint64'tür.
## character\_length, CHARACTER\_LENGTH {#character-length}
Dizenin UTF-8 kodlanmış metni oluşturan bir bayt kümesi içerdiğini varsayarak, Unicode kod noktalarında (karakterlerde değil) bir dizenin uzunluğunu döndürür. Bu varsayım karşılanmazsa, bir sonuç döndürür (bir istisna atmaz).
Sonuç türü Uint64'tür.
## alt, lcase {#lower}
Bir dizedeki ASCII Latin sembollerini küçük harfe dönüştürür.
## üst, ucase {#upper}
Bir dizedeki ASCII Latin sembollerini büyük harfe dönüştürür.
## lowerUTF8 {#lowerutf8}
Dizenin UTF-8 kodlu bir metni oluşturan bir bayt kümesi içerdiğini varsayarak bir dizeyi küçük harfe dönüştürür.
Dili algılamaz. Yani Türkçe için sonuç tam olarak doğru olmayabilir.
UTF-8 bayt dizisinin uzunluğu bir kod noktasının büyük ve küçük harf için farklıysa, sonuç bu kod noktası için yanlış olabilir.
Dize, UTF-8 olmayan bir bayt kümesi içeriyorsa, davranış tanımsızdır.
## upperUTF8 {#upperutf8}
Dize, UTF-8 kodlanmış bir metni oluşturan bir bayt kümesi içerdiğini varsayarak bir dizeyi büyük harfe dönüştürür.
Dili algılamaz. Yani Türkçe için sonuç tam olarak doğru olmayabilir.
UTF-8 bayt dizisinin uzunluğu bir kod noktasının büyük ve küçük harf için farklıysa, sonuç bu kod noktası için yanlış olabilir.
Dize, UTF-8 olmayan bir bayt kümesi içeriyorsa, davranış tanımsızdır.
## ısvalidutf8 {#isvalidutf8}
Bayt kümesi geçerli UTF-8 kodlanmış, aksi takdirde 0 ise, 1 döndürür.
## toValidUTF8 {#tovalidutf8}
Geçersiz UTF-8 karakterlerini değiştirir `<60>` (U+FFFD) karakteri. Bir satırda çalışan tüm geçersiz karakterler bir yedek karaktere daraltılır.
``` sql
toValidUTF8( input_string )
```
Parametre:
- input\_string — Any set of bytes represented as the [Dize](../../sql-reference/data-types/string.md) veri türü nesnesi.
Döndürülen değer: geçerli UTF-8 dizesi.
**Örnek**
``` sql
SELECT toValidUTF8('\x61\xF0\x80\x80\x80b')
```
``` text
┌─toValidUTF8('a<><61><EFBFBD><EFBFBD>b')─┐
│ a<>b │
└───────────────────────┘
```
## tekrarlama {#repeat}
Bir dizeyi belirtilen kadar çok tekrarlar ve çoğaltılmış değerleri tek bir dize olarak birleştirir.
**Sözdizimi**
``` sql
repeat(s, n)
```
**Parametre**
- `s` — The string to repeat. [Dize](../../sql-reference/data-types/string.md).
- `n` — The number of times to repeat the string. [Uİnt](../../sql-reference/data-types/int-uint.md).
**Döndürülen değer**
Dize içeren tek dize `s` tekrarlanan `n` zamanlar. Eğer `n` \< 1, işlev boş dize döndürür.
Tür: `String`.
**Örnek**
Sorgu:
``` sql
SELECT repeat('abc', 10)
```
Sonuç:
``` text
┌─repeat('abc', 10)──────────────┐
│ abcabcabcabcabcabcabcabcabcabc │
└────────────────────────────────┘
```
## tersi {#reverse}
Dizeyi tersine çevirir (bayt dizisi olarak).
## reverseUTF8 {#reverseutf8}
Dizenin UTF-8 metnini temsil eden bir bayt kümesi içerdiğini varsayarak bir Unicode kod noktası dizisini tersine çevirir. Aksi takdirde, başka bir şey yapar(bir istisna atmaz).
## format(pattern, s0, s1, …) {#format}
Bağımsız değişkenlerde listelenen dize ile sabit desen biçimlendirme. `pattern` basitleştirilmiş bir Python biçimi desenidir. Biçim dizesi içerir “replacement fields” kıvırcık parantez ile çevrili `{}`. Parantez içinde bulunmayan herhangi bir şey, çıktıya değişmeden kopyalanan hazır metin olarak kabul edilir. Literal metne bir ayraç karakteri eklemeniz gerekiyorsa, iki katına çıkararak kaçabilir: `{{ '{{' }}` ve `{{ '}}' }}`. Alan adları sayılar (sıfırdan başlayarak) veya boş olabilir (daha sonra sonuç numaraları olarak kabul edilir).
``` sql
SELECT format('{1} {0} {1}', 'World', 'Hello')
```
``` text
┌─format('{1} {0} {1}', 'World', 'Hello')─┐
│ Hello World Hello │
└─────────────────────────────────────────┘
```
``` sql
SELECT format('{} {}', 'Hello', 'World')
```
``` text
┌─format('{} {}', 'Hello', 'World')─┐
│ Hello World │
└───────────────────────────────────┘
```
## concat {#concat}
Bağımsız değişkenlerde listelenen dizeleri ayırıcı olmadan birleştirir.
**Sözdizimi**
``` sql
concat(s1, s2, ...)
```
**Parametre**
String veya FixedString türünün değerleri.
**Döndürülen değerler**
Bağımsız değişkenlerin birleştirilmesinden kaynaklanan dizeyi döndürür.
Argüman değerlerinden herhangi biri ise `NULL`, `concat` dönüşler `NULL`.
**Örnek**
Sorgu:
``` sql
SELECT concat('Hello, ', 'World!')
```
Sonuç:
``` text
┌─concat('Hello, ', 'World!')─┐
│ Hello, World! │
└─────────────────────────────┘
```
## concatassumeınjective {#concatassumeinjective}
Aynı olarak [concat](#concat) emin olun bu ihtiyaç fark var `concat(s1, s2, ...) → sn` enjekte edilir, grup tarafından optimizasyonu için kullanılacaktır.
İşlev adlı “injective” bağımsız değişkenlerin farklı değerleri için her zaman farklı sonuç döndürürse. Başka bir deyişle: farklı argümanlar asla aynı sonucu vermez.
**Sözdizimi**
``` sql
concatAssumeInjective(s1, s2, ...)
```
**Parametre**
String veya FixedString türünün değerleri.
**Döndürülen değerler**
Bağımsız değişkenlerin birleştirilmesinden kaynaklanan dizeyi döndürür.
Argüman değerlerinden herhangi biri ise `NULL`, `concatAssumeInjective` dönüşler `NULL`.
**Örnek**
Giriş tablosu:
``` sql
CREATE TABLE key_val(`key1` String, `key2` String, `value` UInt32) ENGINE = TinyLog;
INSERT INTO key_val VALUES ('Hello, ','World',1), ('Hello, ','World',2), ('Hello, ','World!',3), ('Hello',', World!',2);
SELECT * from key_val;
```
``` text
┌─key1────┬─key2─────┬─value─┐
│ Hello, │ World │ 1 │
│ Hello, │ World │ 2 │
│ Hello, │ World! │ 3 │
│ Hello │ , World! │ 2 │
└─────────┴──────────┴───────┘
```
Sorgu:
``` sql
SELECT concat(key1, key2), sum(value) FROM key_val GROUP BY concatAssumeInjective(key1, key2)
```
Sonuç:
``` text
┌─concat(key1, key2)─┬─sum(value)─┐
│ Hello, World! │ 3 │
│ Hello, World! │ 2 │
│ Hello, World │ 3 │
└────────────────────┴────────────┘
```
## alt dize (s, ofset, uzunluk), orta (s, ofset, uzunluk), substr (s, ofset, uzunluk) {#substring}
Bayttan başlayarak bir alt dize döndürür offset ind thatex yani length uzun bayt. Karakter indeksleme birinden başlar (standart SQL'DE olduğu gibi). Bu offset ve length bağımsız değişkenler sabit olmalıdır.
## substringUTF8(s, ofset, uzunluk) {#substringutf8}
Olarak aynı substring, ancak Unicode kod noktaları için. Dizenin UTF-8 kodlanmış bir metni temsil eden bir bayt kümesi içerdiği varsayımı altında çalışır. Bu varsayım karşılanmazsa, bir sonuç döndürür (bir istisna atmaz).
## appendTrailingCharİfAbsent (s, c) {#appendtrailingcharifabsent}
Eğer... s dize boş değildir ve c sonunda karakter, ekler c sonuna kadar karakter.
## convertCharset (s, from, to) {#convertcharset}
Dize döndürür s bu kodlamadan dönüştürüldü from kod encodinglamaya to.
## base64Encode (s) {#base64encode}
Kodluyor s Base64 içine dize
## base64Decode (s) {#base64decode}
Base64 kodlu dizeyi çözme s orijinal dizeye. Başarısızlık durumunda bir istisna yükseltir.
## tryBase64Decode (s) {#trybase64decode}
Base64decode'a benzer, ancak hata durumunda boş bir dize döndürülür.
## endsWith (s, sonek) {#endswith}
Belirtilen sonek ile bitip bitmeyeceğini döndürür. Dize belirtilen sonek ile biterse 1 değerini döndürür, aksi takdirde 0 değerini döndürür.
## startsWith (str, önek) {#startswith}
Dize belirtilen önek ile başlayıp başlamadığını 1 döndürür, aksi halde 0 döndürür.
``` sql
SELECT startsWith('Spider-Man', 'Spi');
```
**Döndürülen değerler**
- 1, dize belirtilen önek ile başlarsa.
- 0, dize belirtilen önek ile başlamazsa.
**Örnek**
Sorgu:
``` sql
SELECT startsWith('Hello, world!', 'He');
```
Sonuç:
``` text
┌─startsWith('Hello, world!', 'He')─┐
│ 1 │
└───────────────────────────────────┘
```
## kırpmak {#trim}
Belirtilen tüm karakterleri bir dizenin başlangıcından veya sonundan kaldırır.
Varsayılan olarak, bir dizenin her iki ucundan ortak boşlukların (ASCII karakteri 32) tüm ardışık tekrarlarını kaldırır.
**Sözdizimi**
``` sql
trim([[LEADING|TRAILING|BOTH] trim_character FROM] input_string)
```
**Parametre**
- `trim_character` — specified characters for trim. [Dize](../../sql-reference/data-types/string.md).
- `input_string` — string for trim. [Dize](../../sql-reference/data-types/string.md).
**Döndürülen değer**
Önde gelen ve (veya) belirtilen karakterleri izleyen bir dize.
Tür: `String`.
**Örnek**
Sorgu:
``` sql
SELECT trim(BOTH ' ()' FROM '( Hello, world! )')
```
Sonuç:
``` text
┌─trim(BOTH ' ()' FROM '( Hello, world! )')─┐
│ Hello, world! │
└───────────────────────────────────────────────┘
```
## trimLeft {#trimleft}
Bir dizenin başlangıcından ortak boşluk (ASCII karakteri 32) tüm ardışık tekrarlarını kaldırır. Diğer boşluk karakterlerini (sekme, boşluksuz boşluk, vb.) kaldırmaz.).
**Sözdizimi**
``` sql
trimLeft(input_string)
```
Takma ad: `ltrim(input_string)`.
**Parametre**
- `input_string` — string to trim. [Dize](../../sql-reference/data-types/string.md).
**Döndürülen değer**
Bir dize olmadan lider ortak whitespaces.
Tür: `String`.
**Örnek**
Sorgu:
``` sql
SELECT trimLeft(' Hello, world! ')
```
Sonuç:
``` text
┌─trimLeft(' Hello, world! ')─┐
│ Hello, world! │
└─────────────────────────────────────┘
```
## trimRight {#trimright}
Bir dizenin sonundan ortak boşluk (ASCII karakteri 32) tüm ardışık tekrarlarını kaldırır. Diğer boşluk karakterlerini (sekme, boşluksuz boşluk, vb.) kaldırmaz.).
**Sözdizimi**
``` sql
trimRight(input_string)
```
Takma ad: `rtrim(input_string)`.
**Parametre**
- `input_string` — string to trim. [Dize](../../sql-reference/data-types/string.md).
**Döndürülen değer**
Ortak whitespaces firar olmadan bir dize.
Tür: `String`.
**Örnek**
Sorgu:
``` sql
SELECT trimRight(' Hello, world! ')
```
Sonuç:
``` text
┌─trimRight(' Hello, world! ')─┐
│ Hello, world! │
└──────────────────────────────────────┘
```
## trimBoth {#trimboth}
Bir dizenin her iki ucundan ortak boşluk (ASCII karakteri 32) tüm ardışık tekrarlarını kaldırır. Diğer boşluk karakterlerini (sekme, boşluksuz boşluk, vb.) kaldırmaz.).
**Sözdizimi**
``` sql
trimBoth(input_string)
```
Takma ad: `trim(input_string)`.
**Parametre**
- `input_string` — string to trim. [Dize](../../sql-reference/data-types/string.md).
**Döndürülen değer**
Bir dize olmadan lider ve sondaki ortak whitespaces.
Tür: `String`.
**Örnek**
Sorgu:
``` sql
SELECT trimBoth(' Hello, world! ')
```
Sonuç:
``` text
┌─trimBoth(' Hello, world! ')─┐
│ Hello, world! │
└─────────────────────────────────────┘
```
## CRC32 (s) {#crc32}
CRC-32-IEEE 802.3 polinom ve başlangıç değerini kullanarak bir dizenin CRC32 sağlama toplamını döndürür `0xffffffff` (zlib uygulaması).
Sonuç türü Uint32'dir.
## Crc32ieee (s) {#crc32ieee}
CRC-32-IEEE 802.3 polinomunu kullanarak bir dizenin CRC32 sağlama toplamını döndürür.
Sonuç türü Uint32'dir.
## CRC64 (s) {#crc64}
CRC-64-ECMA polinomunu kullanarak bir dizenin CRC64 sağlama toplamını döndürür.
Sonuç türü Uint64'tür.
[Orijinal makale](https://clickhouse.tech/docs/en/query_language/functions/string_functions/) <!--hide-->