แแแแแฎแแแแแ Yandex-แแก แฌแแแแแ แจแแแแแ แแแแแชแแแแ แแแแแแจแ.
- clickhouse
- Odyssey
- แแฆแแแแแ แแ แแแก แแแแแแขแแแแ (WAL-G)
- PostgreSQL (แแแ แจแแ แแก logerrrors, Amcheck, heapcheck)
- แแ แแแแแแแ
แแแแแ:
แฒแแแแ แฏแแแ แแกแแคแแแ! แแ แแฅแแแ แแแแ แแ แแแ แแแแแ. แแ แ แแกแแช แแ แแแแแแแ Yandex.Cloud-แจแ แแ แแก แฆแแ แ แแแแชแแฃแ แ แแแแแชแแแแ แแแแแแแก แจแแแฃแจแแแแแ Yandex.Cloud แแ Yandex.Cloud แแแแแแขแแแแก แแแขแแ แแกแแแแแแ แแแแแแแแแแ แ.
แแ แแแแฎแแแแแจแ แแแกแแฃแแ แแแ แฆแแ แแแแแชแแแแ แแแแแแแก แฌแแแแจแ แแ แกแแแฃแ แแแแแฌแแแแแแแ. แฒ แแขแแ แแ แแก แแก แแแแจแแแแแแแแแ? แแแแขแแ, แ แแ แแแขแแ แ, แแแขแแ แ แแ แแแแแแแแ, แ แแแแแแแช แแแฆแแแแแก แแกแแแแกแแ, แจแแแแแ แกแแแแแแแแ แแฅแชแแแแแ. แแกแแแ แแแแ แฎแแแแแแ, แ แแชแ แแแแ แ แแขแแแแแ แแแฅแแ.
แแแแ แแ แแก แแ แแ แแก แแแแแแ แ. แฌแแ แแแฃแแแแแแแ แ แแ แฎแแแแ. แ แแ, แ แแช แฎแแแแ แแแแแแแแแแ แแ แ แจแแแแฎแแแแแจแ. แฆแ แฃแแแแแแ แแแ แแแแจแ แแ แแแแกแแแแแก แแแแ แฃแแแ แแงแแ, แ แแแแแ แฌแแ แแแฃแแแแแแแ แ แแฆแแชแแแแ แซแแแแแ แกแแแแ แแฃแแ แฎแแแแ, แ แแชแ แ แแฆแแช แแแกแจแขแแแฃแ แแ.
แแแแ แแ! แ แ แฃแแแ แแขแแกแแแ แแฅแแก แฆแแ แแแแแชแแแแ แแแแแแก? แคแแฅแขแแ, แ แแ แแฅแแแ แแแฅแแ แแแแ แแฃแแ แจแแกแแซแแแแแแแ แแแฃแแแแแแแแ แแแแแกแแแแ แแ แแแแแแแก. แแฅแแแ แแแฅแแ แฌแงแแ แแก แแแแ, แแแฅแแ แแ แแแ แแแแ แแแแก แชแแแแ. แฉแแแ แแแแแแกแแแ แแแก แแ แแฃแจแแแแก.
แ แ แแแแแแแแแ แแ แกแแแแแก แฆแแ แแแแแก แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแแ แแฃแจแแแแแกแแก?
- แงแแแแแแ แแแ แขแแแ แแแแแแแ แแ แแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแแแงแแแแแ. แแฃ แแงแแแแแ แแ แแขแแแแแแแก, แแฃ แแงแแแแแ แกแขแแแแแ แขแแแก, แแฃ แแงแแแแแ แคแแ แแแขแแแก, แแฃ แฌแแ แ แจแแแแแฎแแแแก แฆแแ แแแแแก แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแจแ, แแแจแแ แแฅแแแ แฃแแแ แแฎแแ แก แฃแญแแ แ แแแก.
- แแฅแแแ แแแแแแแ แแแก แแแแกแแกแขแแแแก. แแฅแแแ แแแแ แแแ แจแแชแแแแแก แแแ แแฃแแ แแแแแแแแแแก แแแแแแแแแก. แแฅแแแ แแแแ แแแ แแ แกแแกแขแแแแก แกแแแแแแแแแแก. แแฅแแแ แแแแ แแแ แแแแแแแแแ แแแแก แฎแแแแแกแแฌแแแแแแแแก แแแแแ แแ. แแฅแแแ แแฃแแฏแแแแกแแแ แแ แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก. แแฅแแแ แฃแแแ แฎแแ แ แแแแขแ แแแฃแขแแ แ, แแฃ แฃแแ แแแแ แแแแกแ แฃแแแ แกแขแแแแก แแแฆแแแ แแ แแฅ แ แแแแแก แจแแฎแแแ.
- แแแแแ แแ แแ แแแกแแแแแ แแแแแแแ แแ แแก แฆแแ แแแแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแแคแแแแแกแแแ. แแแแแแแแแ, แแแ แแแ แชแแแแแแ Google Summer of Code แแ แแแ แแแ, แ แแแแกแแช Google แฃแฎแแแก แกแขแฃแแแแขแแ แแแ แ แแแแแแแแแก แแแแแ แแกแแคแแแแแแ แแแกแแแแ แคแฃแแก, แ แแแ แแแ แแแแแแแแแ แแ แฆแแ แแ แแแ แแแฃแแ แแ แแแฅแขแแแ, แ แแแแแแแช แแแแแงแแคแแแแแแ แแแ แแแแฃแ แแแชแแแแแ แแแแก แแแแฎแแแแแแก.
- แแก แซแแแแแ แกแแแแขแแ แแกแ แแแแแแแแ, แ แแแแแ แแก แกแแจแฃแแแแแแก แแซแแแแก แแ แแแ แแแฃแ แฃแแ แฃแแแแแงแแคแแก แแแแแแแแ แแแก แกแแแแแแแแแแแกแแแ แงแฃแ แแแฆแแแแก แแแแแขแแแแก แแแ แแจแ. Google, แ แแแแ แช แขแแฅแแแแแแแฃแ แ แแแแแแขแ, แแ แแแแแแก, แ แแ แฉแแแ แแแแแแ แแก แคแฃแแฅแชแแ, แฉแแแ แแแแแแ แแแแแแแกแฌแแ แแ แแก แฎแแ แแแแ แแ แแก แแ แแก แแก, แกแแแแช แฃแแแ แแแแฎแ แ. Google แแแแแแก: โแแแแแ แแก, แ แแกแแช แแแแแแ. แฃแแ แแแแ แแแแแแ แซแแ แแฃแจแแแแ แแกแ, แ แแแแ แช แแฃแจแแแแ แแ แงแแแแแคแแ แ แแแ แแแ แแฅแแแแ. โ
- แฆแแ แฌแงแแ แแจแ แแแแแฌแแแแแแแก แจแแแแแแ แแแแแแแ แแ แแก แแแแแฌแแแแแแ. แ แแแแกแแช แแฅแแแ แแแฅแแ แแ แแแแแแ แฆแแ แแแแแก แแ แแแ แแแแจแ แแ แแ แแแ แแแแแแแแแ แแแ, แแฅแแแแ แแแแแแแแแ แแแ แแฌแงแแแแ แแ แแแแแแแแแก แแแแแแ แแแแก. แแกแแแ แแฌแงแแแแ แแฅแแแแ แแแคแ แแกแขแ แฃแฅแขแฃแ แแก แฃแคแ แ แแคแแฅแขแฃแ แก, แแฅแแแแ แแ แแแ แแแแแแก แฃแคแ แ แกแฌแ แแคแแ แแ แกแแแแแแแแแแก.
แแ แ-แแ แแ แงแแแแแแ แชแแแแแแ Yandex แแ แแแฅแขแ แฆแแ แแแแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แกแคแแ แแจแ แแ แแก ClickHouse. แแก แแ แแก แแแแแชแแแแ แแแแ, แ แแแแแแช แจแแแฅแแแ Yandex.Metrica-แก แฌแแแแจแ แแแแแ แ แแแแแฌแแแแแแแก แแแกแฃแฎแแ.
แแ แ แแแแ แช แแแแแชแแแแ แแแแ, แแแ แแแแแแแ แฆแแ แแแแแ, แ แแแ แจแแแฅแแแแก แแแแกแแกแขแแแ แแ แแแแแแแแ แแแก แแแ แกแฎแแ แแแแแแแแแ แแแแแ แแ แแแ (แแ แ แแฎแแแแ Yandex-แจแ). แแฎแแ แแ แแก แแ แแก แแแแ แแ แแแฅแขแ, แ แแแแแจแแช แแแแ แ แกแฎแแแแแกแฎแแ แแแแแแแแแ แฉแแ แแฃแแ.
Yandex.Cloud-แจแ แฉแแแ แจแแแฅแแแแแ ClickHouse Yandex Object Storage-แแก แแแแแ, แแแฃ แฆแ แฃแแแแแแแ แกแแชแแแแก แแแแแ.
แ แแขแแ แแ แแก แแก แแแแจแแแแแแแแแ แฆแ แฃแแแแจแ? แ แแแแแ แแแแแกแแแแ แ แแแแแชแแแแ แแแแ แแฃแจแแแแก แแ แกแแแแฃแแฎแแแจแ, แแ แแแ แแแแแแจแ, แแแฎแกแแแ แแแแก แขแแแแแแก แแ แแแ แแ แฅแแแจแ. แแฅแแแ แแแฅแแ แกแฌแ แแคแ, แแแแ แแ แแแขแแ แ แ แแแแกแขแ แแแ แแ แแแคแ แแแแ, แแแแ แแ แแแแ SSD, แแงแแ แ แแแกแแแแ แแ แกแฎแแ แแแแแแก แแแฌแงแแแแแแแแแ. แแ แแฃ แแฅแแแ แแคแแฅแขแฃแ แ แฎแแ แ แแแ แแแแแแก แแแแ แแแฌแแแจแ, แแแจแแ แแฅแแแ แแแฅแแ แกแฌแ แแคแ แแแแแชแแแแ แแแแ. แแฃ แแฅแแแ แแคแแฅแขแฃแ แ แฎแแ แ แแ แแแ แแแแแแก แแแแแจแ, แแแจแแ แแแฅแแ แแแกแจแขแแแฃแ แ แแแแแชแแแแ แแแแ. แแ แแ แแฎแ แแ, แฅแแแแแแแ แแแแแ แแ แแ แคแแแแก แแแแแขแแแ แแ แแก แแแแแแฃแ แ แแแแแแแ แแแแแชแแแแ แแแแแก แแแกแจแขแแแฃแ แแแแก แแแแ แแแกแแแแก.
แ แแแแ แจแแแซแแแแแแ แแแแก แแแแแแแแ? แแก แแ แแก แแแแจแแแแแแแแแ แแแแแแขแ แแ แแแฎแกแแแแแแจแ.
- แฉแแแ แจแแแแแซแแแ แแแแแงแแแแ ClickHouse MDS-แแ. MDS แแ แแก Yandex แฆแ แฃแแแแแแแ แจแแแแฎแแแก แจแแแ แแแขแแ แคแแแกแ. แแก แฃแคแ แ แ แแฃแแแ แแแแ แ แฉแแแฃแแแแ แแแ S3 แแ แแขแแแแแ, แแแแ แแ แฃแคแ แ แจแแกแแคแแ แแกแแ แแแแแแก แแแฌแงแแแแแแแแกแแแแก. แฃแแแแแกแแ แแแแแชแแแแแแก แฉแแกแแฌแแ แแ. แแแแก แแแขแ แแ แแแ แแแแ แแแ แกแญแแ แแแแ. แแ แแแ แแแแกแขแแแ แแแแ แแแ แแแแแแ, แแก แแ แแแ แแแ, แกแแแแขแแ แแกแแ.
- S3 แแ แแก แฃแคแ แ แแแแ แชแแแแแฃแแ แแแแแแแ, แ แแแแแแช แแแขแแ แคแแแกแก แฃแคแ แ แแแ แขแแแก แฎแแแก แแแ แแแแฃแแ แขแแแแก แแแขแแแ แแแแแแแ แแแแแแแ แแแแแขแแชแแแก แคแแกแแ.
แแฃแแแแ แแแแ, แแแแก แกแฃแ แแแแแ, แ แแ แแแแแ ClickHouse แแแแกแแกแขแแแ แแแแชแแ แคแฃแแฅแชแแแแแ แแแ แแ แจแแแแกแ แฃแแแ แแก แแแแแแแแ, แ แแแแแแช แกแแญแแ แแ Yandex.Cloud-แแก แจแแแแแ, แแแแแแฌแงแแแขแแ แแแแ แฌแแฃแแแแ, แ แแ ClickHouse-แแก แแแแแ แกแแแแแแแแแแ แแกแแ แแแแแแแแ แแแกแแแ. แฉแแแ แแแแแแฎแแ แชแแแแแ ClickHouse S3-แแ แแ แแ แ ClickHouse MDS-แแ. แแ แแก แแแแ แ แกแแแฃแจแแแ.
แแแฃแแแแ:
"แคแแแแแก แกแแกแขแแแแก แแแกแขแ แแฅแชแแแก แคแแแ"
"AWS SDK S3 แแแขแแแ แแชแแ"
"IDisk แแแขแแ แคแแแกแแก แกแแแแแแกแ แแแแฎแแ แชแแแแแแ S3-แแกแแแแก"
"แแแแแก แจแแแแฎแแแก แซแ แแแแแแก แแแขแแแ แแชแแ IDisk แแแขแแ แคแแแกแแ"
"Log Engine แแฎแแ แแแญแแ แ S3-แแกแ แแ SeekableReadBuffer-แแกแแแแก"
"Storage Stripe Log S3 แแฎแแ แแแญแแ แ"
"Storage MergeTree-แแก แกแแฌแงแแกแ แแฎแแ แแแญแแ แ S3-แแกแแแแก"
"MergeTree แกแ แฃแแ แแฎแแ แแแญแแ แ S3-แแกแแแแก"
"แแฎแแ แแแญแแ แ ReplicateMergeTree S3-แแ"
โแแแแแแขแแ แแแแฃแแแกแฎแแแแ แกแแ แแแคแแแแขแแแ แแ แแแ แแแแฃแแ แกแแแแฃแ แแแ s3 แจแแแแฎแแแกแแแแกโ
"S3 แแแแแแแฃแ แ แแ แแฅแกแ แแแแคแแแฃแ แแชแแแ"
"S3 แแ แแฅแกแ แแแแแแฌแงแแแขแแ"
แแก แแ แแก แแแแฎแแแแแก แกแแ ClickHouse-แจแ แแแ แขแฃแแแฃแ แ แคแแแแฃแ แ แกแแกแขแแแแก แแแกแแแแ แแแ. แแก แแ แแก แแแแฎแแแแแก แแแแ แ แแแแแแแแ.
แแแฃแแแแ:
"DiskS3 hardlinks แแแขแแแแแฃแ แ แแแแฎแแ แชแแแแแแ"
"S3 HTTP แแแแแแขแ - แแแแ แแแแ แแแกแฃแฎแแแแก แแแแแแแก แแแฎแกแแแ แแแแจแ แแแแแ แแแแก"
แแแแ แแแแ แแแกแฃแฎแแแแก แแแแแ แแแแแแแก แแแแแ แแแแก แแแฎแกแแแ แแแแจแ S3 HTTP-แจแ
แแแแแแขแ"
"S3 แแแกแแแกแแแแก แคแแแแแแแก แฅแแจแแ แแแแกแ แแ แแแแแฅแกแแ แแแแก แจแแกแแซแแแแแแแ"
"แแแฌแแแแแแก แแแแแขแแแ DiskLocal-แแแ DiskS3-แแ แแแ แแแแแฃแ แแ"
แแแแ แแ แกแแแฃแจแแ แแแแ แแ แแแกแ แฃแแแแฃแแ. แคแฃแแฅแชแแแก แจแแฅแแแแก แจแแแแแ, แแแแแ แ แแแแแแแแ แกแแแฃแจแแ แแงแ แกแแญแแ แ แแ แคแฃแแฅแชแแแก แแแขแแแแแแชแแแกแแแแก.
แแแฃแแแแ:
"แแแแแแขแ SelectedRows แแ SelectedBytes แแแแแแแแแ"
"S3 แแแแฎแแแแแแแ แแ แแคแแแแ แแแแก แแแแแแแแแแก แแแแแขแแแ system.events"
"แแแแแแขแ QueryTimeMicroseconds, SelectQueryTimeMicroseconds แแ InsertQueryTimeMicroseconds"
แจแแแแแ แแ แกแแญแแ แ แแงแ แแแกแ แแแแแแแกแขแแแ, แแแแแขแแ แแแแแก แแแงแแแแแ แแ แแแ แแแแแ.
แแ แแก แงแแแแแคแแ แ แแกแ แแแแแแแ, แ แแ แแแแแแ แกแแแแแแแแแแแ, ClickHouse-แแก แแแแแแ แแแแกแแกแขแแแแ แแแแฆแ แแ แกแแแฃแจแแแก แจแแแแแ.
แแแแแแแแแ แขแ แแแแแฅแชแแฃแ แแแแแชแแแแ แแแแแแแ, OLTP แแแแแชแแแแ แแแแแแแ, แ แแแแแแแช แแแ แแแแ แฉแแแแแแก แฃแคแ แ แแฎแแแกแแ.
แแก แแ แแก แฆแแ แแแแแก DBMS แแแแแแแแ แแแแก แแแแงแแคแแแแแ. แแก แแแญแแแ แแแแแแแแ แฅแฃแฉแแก แแแแแแก แขแ แแแแแฅแชแแแก แฆแแ แแแแแชแแแแ แแแแแแแก แแแกแแฃแแฏแแแแกแแแแแ.
แแ แ-แแ แแ แแ แแแฅแขแ, แ แแแแแก แแแแแแแแแก แแแแแงแแแแแแ แจแแแแแซแแแ แแแกแแฃแแ แแ แแแแแ, แแฃ แ แแแแ แแ แ แแก แแแแแแแแ, แแ แแก Connection Pooler in Postgres.
Postgres แแ แแก แแ แแชแแกแแแแก แแแแแชแแแแ แแแแ. แแก แแแจแแแแก, แ แแ แแแแแชแแแแ แแแแแก แฃแแแ แฐแฅแแแแแก แ แแช แจแแแซแแแแ แแแแแแแ แฅแกแแแฃแ แ แแแแจแแ แ, แ แแแแแแช แแฎแแ แชแแแแแแก แขแ แแแแแฅแชแแแแก.
แแแแ แแก แแฎแ แแ, แฆแ แฃแแแแแแ แแแ แแแแจแ, แขแแแแฃแ แ แกแแขแฃแแชแแแ, แ แแแแกแแช แแแแกแ แแแแจแแ แ แแ แแแ แแฃแแแ แแแแแก แแ แ แแแแกแขแแ แจแ. แแ แแแแจแแ แแก แแฃแแแ แแก แแแแชแแแแ แจแแคแฃแแแก แแแแกแ แแแแจแแ แ แกแแ แแแ แแก แแแแจแแ แแแแก แแชแแ แ แ แแแแแแแแแจแ.
แจแแแแแซแแแ แแแฅแแแ, แ แแ แแแแจแแ แแก แแฃแแแ แ แแ แแก แกแแขแแแแคแแแ แแแแ แแขแแ แ, แ แแแแแแช แแแแแแฌแงแแแก แแแแขแแแก แแกแ, แ แแ แแกแแแ แแคแแฅแขแฃแ แแ แแแแฆแฌแแแ แแแแแชแแแแ แแแแแก.
แกแแแฌแฃแฎแแ แแ, แแ แแ แกแแแแแก แแแ แแ แ แฃแกแฃแแ แกแแขแงแแ แแแแจแแ แแก แแฃแแแ แแกแแแแก. แแแแฏแแ แแแก แแฃแแขแแแแแฅแกแแ แแก แแแแจแแ แแแก แฃแฌแแแแแแ. แแฃ แแชแแ, แ แ แแแแ แฅแแ แแแแจแแ แแก แแฃแแแ แก, แแแจแแ แแฃแชแแแแแแแ แแแแฎแแ แแ, แแแแ แกแแแแแแแแแแ แแแกแแฃแแ แแ แกแฌแแ แแ แ แฃแกแฃแ แขแแฅแแแแฃแ แแแแแ.
แฉแแแ แแแแแแแแแแแแ แแแแจแแ แแก แแฃแแแ แแแ, แ แแแแแแแช แจแแกแแคแแ แแกแ แแงแ แแแ แแฃแแ แแแกแขแแ แแก แแแแกแขแแ แแกแแแแก. แแ PgBouncer แฉแแแแแแแก แกแแฃแแแแแกแ แแ แฉแแแแแ แแงแ. แแแแ แแ แฉแแแ แจแแแฎแแแแ แฃแแแ แแ แแ แแแแแแแก PgBouncer-แแแ แแแแแแจแแ แแแแ. แแ แแแแแ แฌแแแก แฌแแ, แแแแแแแ แแแ แแแแแแ แแแกแชแ แแแฎแกแแแแแแแ, แ แแ แฉแแแ แแแงแแแแแ PgBouncer-แก, แแแแแฌแแแก แงแแแแแคแแ แ, แแแแ แแ แแ แแก แแแฃแแแกแแแ, แแ แแก แ แแฆแแชแแแ แแฃแจแแแแ.
แแ แแแแฃแจแแแแ. แฉแแแ แแแแแคแแฅแกแแ แแ แแ แแแแแแแแ, แ แแแแแแแช แจแแแแฎแแแ, แแแแแงแแแแ Bouncer แแ แจแแแแชแแแแ แแแแแฌแแ แแแแฎแแแแแแ แแแแแ. แแแแ แแ แคแฃแแแแแแแขแฃแ แ แแ แแ แซแแคแแ แแฃแจแแแแ แ แแฃแแ แแงแ.
แฉแแแ แแแแแแฌแแ แแแกแแแแแแแก แจแแแ แแแแแ แจแแแแ แแแ Bouncer-แแแแแแ. แ แแแแกแแช แแแแฅแแก แแแแ แ แแ แแแแแแแแแแ Bouncers, แแแแ แคแแแแก แแแแจแแ แแแ แแแแแแแก Bouncers-แแก แจแแแ แคแแแแแ. แแก แแ แแก แชแฃแแแ แแแ แแฃแแ แกแแกแขแแแ, แ แแแแแก แแจแแแแแ แแ แแแคแแ แแแแแ แ แแฃแแแ.
แแแแแแแ แแแกแแแแแแแ, แ แแ แจแแแฅแแแแแ แฉแแแแ แกแแแฃแแแ แ แแแแจแแ แแก แแฃแแแ แ, แ แแแแแกแแช แแแแกแแ แฐแฅแแแ. แฉแแแ แแแแฌแแ แแ แแฃแแแแแ.
2019 แฌแแแก, PgCon แแแแคแแ แแแชแแแแ, แแ แฌแแ แแแแแแแ แแก แแฃแแแ แ แแแแแแแแแ แแ แกแแแแแแแแแแแก. แแฎแแ GitHub-แแ 2 แแแ แกแแแแแแแ แชแแขแ แแแแแแแ แแแแฅแแก, แแแฃ แแ แแแฅแขแ แชแแชแฎแแแแ, แแ แแแฅแขแ แแแแฃแแแ แฃแแแ.
แแ แแฃ แแฅแแแ แจแแฅแแแแ Postgres แแแแกแขแแ แก Yandex.Cloud-แจแ, แแแจแแ แแก แแฅแแแแ แแแแกแขแแ แ แฉแแจแแแแแฃแแ Odyssey-แแ, แ แแแแแแช แฎแแแแฎแแ แแแแคแแแฃแ แแ แแแฃแแแ แแแแกแขแแ แแก แฌแแ แแ แฃแแแ แแแกแจแขแแแแ แแแแกแแก.
แ แ แแแกแฌแแแแแ แแ แแ แแแฅแขแแกแแแ? แแแแแฃแ แแแขแฃแแ แแ แแแฅแขแแก แแแจแแแแ แงแแแแแแแแก แแแ แแกแแฃแแ แแแแแฏแแ, แฃแแแแฃแ แแกแ แแแแแ, แ แแชแ แแแแแแแ, แ แแ แแ แแก แแ แแแแแแแแ, แ แแแแแแแช แแ แฌแงแแแแ แกแแแแแ แแกแแ แกแฌแ แแคแแ, แแ แฌแงแแแแ แแ แแ แแแก แแแขแแ แแแแแแจแ, แ แแช แฉแแแแแแแก แจแแกแแคแแ แแกแแ. แแแแ แแ แแก แแคแแฅแขแฃแ แ แฆแแแแกแซแแแแแ.
PgBouncer แแแแฌแงแ แฃแคแ แ แกแฌแ แแคแแ แแแแแแแแ แแแ.
แแฎแแ แแ แกแฎแแ แแ แแแฅแขแแแ แแแแแฉแแแ. แแแแแแแแแ, pgagroal, แ แแแแแแช แจแแแฃแจแแแแแฃแแแ Red Hat-แแก แแแแแแแแแ แแแแก แแแแ . แแกแแแ แแแกแแแแแ แแกแแแแก แแแแแแแก แแ แแฎแแ แชแแแแแแแ แแกแแแแก แแแแแแก, แแแแ แแ, แ แ แแฅแแ แฃแแแ, แกแแแฃแแแ แ แกแแแชแแคแแแแ, แ แแช แฃแคแ แ แแฎแแแกแแ pgagroal-แแก แแแแแแแแแ แแแแแ.
แแแกแขแแ แแกแแก แกแแแแแแแแแแแกแแแ แแฃแจแแแแแก แแแแแ แแ แแ แจแแแแฎแแแแ แแ แแจแ แแฆแแแแแ. แแก แแ แแก แแฆแแแแแ แฌแแ แฃแแแขแแแแแแแก แจแแแแแ, แแก แแ แแก แแฆแแแแแ แกแแ แแแแ แแแแแ.
แแแแ แ แกแแ แแแแ แแ แกแแจแฃแแแแแแ แแ แแกแแแ แงแแแแ แแแแกแฎแแแแแแฃแแแ. Postgres-แแก แแแแฅแแแก แงแแแแ แแแแงแแแแแแก แแฅแแก แกแแแฃแแแ แ แกแแ แแแแ แแ แแแแแฌแงแแแขแ.
แแฃ แแแฆแแแ แงแแแแ แกแแ แแแแ แแ แกแแกแขแแแแก, แจแแฅแแแแ แคแฃแแฅแชแแแแแก แแแขแ แแชแแก แแ แฎแฃแแ แแแแ แแแแแแแแแ แแ แแแขแ แแชแแจแ แแแแแกแแแฆแแ แแแก, แแก แแฅแแแแ แแฃแแ. แฒ แแก แแแจแแแแก แแก? แ แ แแแฎแแแแ, แแฃ แแฅแแแ แแฆแแแ แแแแแ แแขแฃแ แกแแ แแแแ แแ แคแแแแก, แแแจแแ แแแกแ แจแแแ แแแ แจแแฃแซแแแแแแแ แงแแแแ แแแแแ แฉแแแแกแแแ. แฃแแแแแแฃแ แแ แแแแแกแ แแแแฎแแ แชแแแแแแแ, แฃแแแแแแฃแ แแ แแแแแกแ แแแแแจแแฃแแแแแ, แฃแแแแแแฃแ แแ แแแกแจแ แฉแแแแแฃแแ แแแแแแแ. แแ แแกแแแ แงแแแแ แกแแแชแแคแแแฃแ แแ.
แกแแแแ แแ แกแแแแแฎแแ แแแฃแจแแแแแแ, CitusData-แ แฌแแแแแฌแงแ WAL-G แแ แแแฅแขแ. แแก แแ แแก แกแแ แแแแ แแ แกแแกแขแแแ, แ แแแแแแช แจแแแฅแแแ แฆแ แฃแแแแแแแ แแแ แแแแก แแแแแแแแกแฌแแแแแแ. แแฎแแ CitusData แฃแแแ Microsoft-แแก แแแฌแแแแ. แแ แแ แแแแแแขแจแ แฉแแแ แซแแแแแ แแแแแฌแแแแ แแแแแแ, แ แแแแแแแช แฉแแแแงแแแแแแ WAL-G-แแก แกแแฌแงแแก แแแแแจแแแแแแจแ. แแ แฉแแแ แแแแแฌแงแแ แแ แแ แแแฅแขแจแ แฌแแแแแแก แจแแขแแแ.
แแฎแแ แแ แแ แแแฅแขแจแ แแ แแแแแ แแแแฃแแ แแแแแแแแแ แแ, แแแแ แแ WAL-G-แแก แแแแฃแแจแ แจแแแแก 10 Yandexoid. แแฅ แแแแ แ แฉแแแแ แแแแ แแแแแงแแแแแ. แแ, แ แ แแฅแแ แฃแแแ, แฉแแแ แแแแแแ แแแแแแฎแแ แชแแแแแ แแกแแแ, แแแแแ แแแแแแชแแแแ แแกแแแ, แฉแแแ แแแแแแ แแแแแแแขแแแแ แฌแแ แแแแแแจแ, แฉแแแ แแแแแแ แแแงแแแแแ แแแ, แฉแแแ แแแแแแ แแฎแแแแแแ, แกแแ แฃแแแ แแแแแแแแแ แจแแแแแ, แแแ WAL-G แกแแแแแแแแแแแกแแแ แฃแ แแแแ แแแแแกแแก.
แแ แฉแแแแ แแแแแกแแแ แแกแแ, แแฎแแ แแก แกแแ แแแแ แแ แกแแกแขแแแ, แแแ แจแแ แแก แฉแแแแ แซแแแแกแฎแแแแแก แแแแแแแแกแฌแแแแแแ, แแแฎแแ แแแขแแแแแฃแ แ แฆแ แฃแแแแแแแ แแแ แแแแกแแแแก. แแก แแ แแก แกแแฃแแแแแกแ แฆแแ แแแฃแแแแ Postgres-แแก แกแแ แแแแ แแ แแกแแแก แจแแกแแฅแแแแแแ แฆแ แฃแแแแจแ.
แฒ แแก แแแจแแแแก? แฉแแแ แกแแแแแแ แแแ แแแแแก แแฃแญแแ แแแ แแแแฃแแแ แแแแชแแแก: แกแแ แแแแ แแ แแกแแ แฃแแแ แแงแแก แฃแกแแคแ แแฎแ, แแแคแ แแแแแกแแงแแแแแแแ แแ แ แแช แจแแแซแแแแ แกแฌแ แแคแแ แแฆแแแแแแแ.
แ แแขแแ แฃแแแ แแงแแก แแแคแ แแฃแจแแแแ? แ แแแแกแแช แแ แแคแแ แ แแ แแ แแก แแแขแแฎแแแ, แแ แฃแแแ แแชแแแแ, แ แแ แแแฅแแ แกแแ แแแแ แแ แแกแแแแ. แงแแแแแคแแ แ แแแ แแแ แแฃแจแแแแก, แแฅแแแ แฎแแ แฏแแแ แ แแช แจแแแซแแแแ แแแแแแ CPU-แก, แแงแแแแแ แ แแช แจแแแซแแแแ แแแแแแ แแแกแแแก แ แแกแฃแ แกแก แแ แ แแช แจแแแซแแแแ แชแแขแ แแแแขแก แแแแแแแแ แฅแกแแแจแ, แ แแแ แฎแแแ แแ แจแแฃแจแแแแ แแฅแแแแ แฆแแ แแแฃแแ แกแแ แแแกแแแแก แแแขแแแ แแแแก.
แแ แ แแชแ แงแแแแแคแแ แ แแจแแแแ, แแแแแแแแแ, แแแแแแแกแขแ แแขแแ แแ แแแแแแ แแแแแชแแแแแ, แ แแฆแแช แแ แแกแฌแแ แแ แฌแแ แแแแ แแ แแ แกแแกแฌแ แแคแแ แฃแแแ แแแแ แฃแแแ แฌแแ แกแฃแแจแ, แแแแแ แคแฃแแแ แแฆแแแแก, แ แแแแแ แแแแแ, แ แแ แจแแแ แแแแแชแแแแแ แกแฌแ แแคแแ แแ แฎแแแฃแฎแแแแแแ แแแแ แฃแแแแก.
แแ แฉแแแ แแ แแแ แขแแ แแแแแก แแแแฃแฌแแแ แแแแฃแแแ แแแแชแแ. แแ, แ แแแแ แช แฉแแแก, แฉแแแ แแแแแฎแแ แฎแแ แแแกแ แแแแฎแแ แชแแแแแแ.
แแแแ แแ แแก แงแแแแแคแแ แ แแ แแ แแก. แแแแแ แแ แแ แแแขแแ แ แ แแ แแแแแแแแ. แฉแแแ แแแแแแแแ แแ แแแแแ แแแแกแฎแแแแแแฃแแ แแแแแชแแแแ แแแแ. แงแแแแ แฉแแแแ แแแแแแขแ แแ แแงแแแแแก Postgres-แก. แแแแ แแงแแแแแก MySQL, MongoDB. แกแแแแแแแแแแแจแ, แกแฎแแ แแแแแแแแแ แแแแ แแฎแแ แ แแแฃแญแแ แแก FoundationDB-แก. แแ แแก แกแแ แแฃแแแแแแ แคแแ แแแแแแแ.
แกแแแแแแแแแแแก แแแกแฌแแแก แแแแแชแแแแ แแแแแก แแแจแแแแแก แแแแ แฆแ แฃแแแแจแ แแแ แแฃแ แแแ แแแแจแ. แแ แแแแแแแแแ แแแ แแแแ แฉแฃแแแแแ แแแแแแแ แแแแแชแแแแ แแแแแแก, แ แแแแแแ แกแแ แแแแ แแ แแกแแแแ แแ แแแแแ แแ แจแแกแแซแแแแแแแ Postgres-แแแ แแ แแแ แฉแแแแ แกแแ แแแแ แแ แกแแกแขแแแแ.
แ แ แแแกแฌแแแแแ แแ แแแแแแแ? แฉแแแแ แแ แแแฃแฅแขแ, แ แแแแ แช แแแแแแแแ แแแแก แแแแงแแคแแแแแ, แแ แแ แแก แแแแแก แฎแแแแแ, แแก แแ แแ แแก แแแแชแฎแแแแแแแ, แแก แแ แแ แแก แคแแแแแแ. แฉแแแแ แแ แแแฃแฅแขแ แแ แแ แแก แแแแฎแแแแ. แแก แแก แแแแแแแ, แ แแแแแแกแแช แกแแแแแแแแแแแก แแแฌแแแแ. แแก แแ แแก แขแแฅแแแแแแแฃแ แ แแฅแกแแแ แขแแแ แแ แขแแฅแแแแแแแแก แแแซแ แแแแ แฆแ แฃแแแแแแแ แแแ แแแแกแแแ.
แแ แกแแแแแก แแแแแชแแแแ แแแแ, แ แแแแ แแชแแ Postgres. แงแแแแแแ แแแขแแ แแแกแขแแ แแกแแก แแแ แแแ แแแแฌแแแก. แแ แแแ แแ แแก แแแขแแ แแ แแแกแขแแ แแกแแก แแแ แแแแก แแแแแแแแ แแแแแ แกแแแแแแแแแแแกแแแ.
แแแแ แแ แแฅ แฃแแแ แแแฅแแแก, แ แแ Yandex.Cloud-แก แแฅแแก แแแ แแฃแแ แแแแแชแแแแ แแแแแแแก แจแแแ แแแกแขแแแแชแแ. แแ แแก แแแแ แฎแแแก แฌแแ แแแแฌแงแ Yandex.Mail-แจแ. แแฅแกแแแ แขแแแ, แ แแแแแแแช แแฎแแ แแแแงแแแแ แแแ แแฃแแ Postgres, แแแแ แแแแ, แ แแแแกแแช แคแแกแขแ แกแฃแ แแ แแแแแกแฃแแแงแ Postgres-แจแ.
แคแแกแขแแก แซแแแแแ แแกแแแแกแ แแแแฎแแแแแแ แแฅแแก แฆแ แฃแแแแแแ. แแแก แกแญแแ แแแแ, แ แแ แจแแซแแแ แแฅแแแแ แแแแแชแแแแแแก แแแแแกแแแแ แฌแแ แขแแแจแ แแแฃแแแแแแแ แแฅแกแแแแแแชแแฃแ แ แแ แแแก แแแกแจแขแแแแ แแแ. แแ แคแแกแขแ แฃแแแ แแแขแแแ แแฃแแ แแงแ แแกแแแแ แแแแแแแ แกแแคแแกแขแ แงแฃแแแ แฃแแแ แแแ แแแแฎแแแ แแแแแกแแแ, แ แแแแแแแช แแฃแแแแแแ แฃแฌแแแแ แแแแ แแแแฎแแแแแก.
แแ แแก แกแแแแแแ แกแแ แแแแฃแแ แแแแแฌแแแแ แแงแ แแฃแแแแกแแแแก, แ แแแแแแช แแแแแแ แแแแ Postgres-แก. แแแจแแ, แแแแแกแแแแ แ แแ แแแแแแ, แ แแแแแแช แจแแแแฎแแแ, แแชแแแแแแแแ แกแแแแแแแแแแแก. แแ แแก แแ แแแแแแแแ แแแแแกแฌแแ แแ แแ แแแแแกแฌแแ แแ แกแแแแแแแแแแแก แแแแ แแแแแแ แ แแแแแแแก, แแฃแแแแช แแแแแแ แแ แกแฎแแ แแแแแชแแแแ แแแแแก แคแแกแแแแ แแฎแแ แแแญแแ แแก แแแแแแ แแ แแแแแ แฃแแแแแกแ. แแแฃ แจแแแแซแแแแ แฌแแ แแแ แแแฃแแแแแแแ PgSQL แฐแแแแ แก แแ แแแแฆแแ แแแกแฃแฎแ 40 แฌแฃแแจแ. แแแแแแ แ แแแแแชแแแแ แแแแแจแ แคแแกแแแแ แแฎแแ แแแญแแ แ แจแแแซแแแแ แคแแฅแ แแแแแก, แ แแ แฃแคแ แ แแ แแแ แแขแแขแฃแแ แ แแ แแ แแก, แแแแ แ แแฅแแแแ แจแแชแแแแ.
แแฎแแ Postgres-แแก แจแแแ แแแกแขแแแแชแแ แแ แแก แ แแแแแแแแ แแแขแแแแแขแ แแแแแชแแแ. แแก แแ แแก แ แแแแแแแแ แแแแแแแ แแแแฎแแแแ แฌแแแจแ. แแก แแ แแก แแแแกแแแแ แแขแแแแแ. แซแแแแแ แแแกแจแขแแแฃแ แแ.
แแแแ แแ แแ แแก แแแฃแแแกแ. แแก แชแฎแแแ แแแก แแ แ แแแแแแ แฅแกแแแแก แแแกแแแแแ, แแ แแแแ แกแแแแแแ แแแ แขแแ แแแแ แแขแฃแ แแแ. แแ แแ แแก แกแแขแแกแขแ แแแ แแแ แกแแแชแแแแฃแ แแ แกแแแแขแแ แแกแ แแฎแแแ แแแแแแแแกแแแแก.
แแ แแแ แแแแฃแ แแแแแแขแจแ แขแแกแขแแก แแแ แแแแจแ แแแแแฆแแ แจแแขแงแแแแแแแ, แ แแแแแแช แแแฃแแแแแแแ, แ แแ แแแแ แฆแแ แแแแแชแแแแ แแแแแก แแแแแฅแกแแแแก แจแแแ แแแแแ แแแแขแแแ.
แฃแชแแแแแ แแ แแก แแ แแแแแ แ แฃแ แแแแ แแแแ, แ แแแแแกแแช แฉแแแ แงแแแแแแแแก แแแแแแแแแ.
แซแแแแแ แแ แแขแแแฃแแ แกแแขแฃแแชแแแ แฉแแแแแแแก. แแก แแแฃแแแแแแก, แ แแ แแแแแแ แแ แแแแแชแแแ แจแแแซแแแแ แแแแแแ แแ. แแ แแแแแชแแแแ แแแแแ แแแ แแ แแก แ แแฆแแช แกแ แฃแแแแ แแแขแแกแขแ แแคแฃแแ.
แแแแแแ แแแแ, แ แแแแแกแแช แฉแแแ แแแแงแแแแแ แแแ แแฃแ แแแแแชแแแแ แแแแแแจแ, แแ แแก แแก, แ แแ แซแแแแกแฎแแแแแก แจแแแแฎแแแแแจแแช แแ, แ แแฃแแ แแฅแแแแ แแแแแชแแแแ แแแแแ แแแ. แแแจแแแแช แแ, แแฃ แแแ แแแแแ แแฎ แแแแแฆแแแ, แแฅแแแ แแแแแช แแแแญแแ แแแแแ แแแแ แแ แงแแคแแแก แแแแ แฎแแแก แแแแแแแแแแแจแ แแแแแ แแ แแแ. แแแแแชแแแแ แฃแกแแคแ แแฎแแแแ แแ แแก แ แแแแแแ, แ แแแแแกแแช แฉแแแ แกแแแแแแ แแฃแแแแแแแแแ แแแแงแแแแแ.
แแ แแฅ แฉแแแแแ แกแแขแฃแแชแแ, แ แแแแแแช แแแ แแฃแแแแก, แ แแ แจแแแซแแแแ แแงแแก แกแแขแฃแแชแแ, แ แแแแแกแแแแกแแช แจแแแซแแแแ แแ แแแงแแ แแแแ. แแ แฉแแแ แแแแแฌแงแแ แแแแแแแ แแ แกแแขแฃแแชแแแกแแแแก.
แแแ แแแแ, แ แแช แแแแแแแแแ, แแงแ แแ แแแแกแแแแ แแขแแแแแก แแแ แแแ. แฉแแแ แแฆแแแแแฉแแแแ, แ แแแแแ แแแแกแขแแ แแแ แแงแ แแแแแแแกแแแฃแแ แแ แแแแแแฃแ แ แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แแฅแแแ แแแกแแแแแ, แ แแแแแแแช แแแ แแแแแแแ แแแแแชแแแแ แแแแ แแแก แแแแแฎแแแแแแก. แแแแแจแแฃแแแ แงแแแแ Postgres แแแแแชแแแแ แแแแ. แฉแแแ แแฆแแแแจแแแ แแก แจแแขแงแแแแแแแแแ, แ แแแแแแแช แแแฃแแแแแแก แจแแแ แแแแแ แแแแขแแแแก แแแ แฆแแแแแแ แแแแแ, แ แแแแแแช แจแแฅแแแแแแ แแแแแชแแแแ แแแ แฃแคแชแแแก แแแแแกแแแแแแแ.
แแก แแแขแฉแ แแ แแฅแขแแแฃแแแ แแแฆแแแฃแแ แแฅแแ แกแแแแแแแแแแแก แแแแ แแแแ แแแกแแฃแกแแแก แแแ แแจแ, แ แแแแแ แแแแแแฃแ แแแแแ แแขแฃแ แจแแแแฎแแแแแจแ แแจแแแ แ แแงแ, แ แแ แ แแฆแแช แชแฃแแ แแแฎแแ แแ แกแแญแแ แ แแงแ แแฃแ แแแแจแ แจแแขแงแแแแแแแแแ.
แแแแก แจแแแแแ แแแแแแแ แแฅแแแแ, แ แแ แแแแฅแแก แแแแแขแแ แแแแ, แ แแแแแแช แกแแแแแ แแแก แแฃแ แแแแแแก. แกแแแญแแ แจแแขแงแแแแแแแแแแก แจแแแแฎแแแแแจแ แแ แแแ แแแแก แแฆแแแซแแแก, แแแ แแแ แแ แจแแแแแแแก.
แแแแ แแ! แแฃแ แแแแแแแก แกแแแแแ แแแ แแแคแ แแแแ แแชแแแ แแ แ แแแแกแขแแ แแ แแ แแแขแแกแขแ แแคแฃแแแ แซแแแ แ แแแแกแ แแแแกแขแแ แแกแแแแก.
แฉแแแ แแแแฌแแ แแ แแแคแแ แแแแแ แ.แฌ . แแก แฅแแแแก แแแแแชแแแแ แแแแแก แฎแแแก, แ แแแแแจแแช แจแแแแซแแแแ แแแคแแ แแ แกแฌแ แแคแแ แจแแแ แฉแแแ แกแขแแขแแกแขแแแ แฌแแ แกแฃแแแก แจแแชแแแแแแแ. แแ แแฃ แแแแแญแแ แแแแ แแแ แแแ แแคแแชแ แแก แแแฆแแแซแแแ, แแแจแแ แแแแก แจแแกแแฎแแ แแแแแแแแ แแแแแแแแขแแแแ แคแแแแแแแก แกแแแแแ แแแแก แแแ แแจแ, แแแแ แแ แฐแแจแแก แชแฎแ แแแแแแ แ แแแแแแแแ แแแแขแแก แแแแฆแแแแ.
แแก แแแคแแ แแแแแ แแแฆแแแฃแแแ, แแแแแแแแแ, แกแแชแแแจแ . แแฃ แแกแฃแ แ แแแกแ แแแแแงแแแแแ, แจแแแแซแแแแ แแแแแ แแแแแแกแขแแแแ แแ. แ แ แแฅแแ แฃแแแ, แแก แแ แแก แฆแแ แฌแงแแ แ.
แแแแ แแ แแก แงแแแแแคแแ แ แแ แแ แแก. แฉแแแ แแแแแฌแงแแ Amcheck-แแก แแแแแงแแแแแ, แกแแแแแแแแแแแก แแแแ แจแแฅแแแแแ แแแคแแ แแแแแ, แแแแแฅแกแแแจแ แฃแชแแแแแ แแแ แฆแแแแแแแก แแแกแแซแแแแแ.
แแ แฉแแแ แแแแแ แแแแแ, แ แแ แแฃ แแแก แแแกแจแขแแแแ แแแฃแจแแแแแ, แแ แแก แจแแชแแแแแแ. แแแแแฌแงแแ แแแแ แแแแแกแฌแแ แแแ. แฉแแแแ แจแแกแฌแแ แแแแแ แแแฆแแแฃแแแ.
แฉแแแ แแฆแแแแแฉแแแแ, แ แแ แแ แแแคแแ แแแแแแก แแ แจแแฃแซแแแ GiST & GIT แแแแแฅแกแแแแก แแแแแแแ. แฉแแแ แแแ แแฎแแ แ แแแแฃแญแแ แแ. แแแแ แแ แแก แแฎแแ แแแญแแ แ แฏแแ แแแแแ แแแแแฎแแแแแ แกแแแแแแแแแแแก แแแแ , แ แแแแแ แแก แจแแแแ แแแแ แแฎแแแ แคแฃแแฅแชแแแแแ แแแแ แแ แแแแ แ แแแขแแแแ.
แฉแแแ แแกแแแ แแฆแแแแแฉแแแแ, แ แแ แ แแแแแแแชแแแก แแแแแ แแ, แแแกแขแแ แแ แแแ แฆแแแแแก แแแแแฅแกแแแแก แจแแแแฌแแแแแกแแก, แงแแแแแคแแ แ แแแ แแแ แแฃแจแแแแก, แแแแ แแ แ แแแแแแแแแ, แแแแแแแแ แแ, แแแ แฃแคแชแแแก แซแแแแ แแ แช แแกแ แแคแแฅแขแฃแ แแ. แงแแแแ แฃแชแแแแแ แแ แแ แแก แจแแแแฌแแแแฃแแ. แแ แแ แแ แฃแชแแแแแ แซแแแแแ แแแแฌแฃแฎแแแแ. แแ แฉแแแ แแแแแขแแ แแ แฌแแแแฌแแแแแฎแแแแ แ แกแแแแแแแแแแแกแแแ แแแแฃแแแแแชแแแจแ, แ แแแ แฉแแแแแ แแ แแก แจแแแแฌแแแแ แ แแแแแแแแแ.
แฉแแแ แแแแฌแแ แแ แแแแ, แ แแแแแแช แฃแแแ แจแแแกแแแแแแแแแแก แงแแแแ แฅแแแแก... แแ แแขแแแแแก. แฉแแแ แกแแแแแแ แแแแ แฎแแแก แแแแแแแแแแแจแ แแแแแแฎแแแแแแแ แแ แแแขแฉแก แแแขแแ แแแแแแแแ แแ แแแ Crunchy Data-แแแ. แแแก แแแฃแฌแแ แแแแแ แจแแชแแแแแแงแ แแแกแขแแ แแกแจแ แแ แกแแแฃแแ B-แฎแ, แ แแแ แแแแฆแ แแก แแแฉแ. แแก แแแแฆแแก. แแฎแแ แแ แ แแแแแแแแแ แแแแแฅแกแแแแก แจแแแแฌแแแแ แแกแแแ แกแแแแแ แแกแแ แแคแแฅแขแฃแ แ แแแฎแแ แแ แแแ แฆแแแแแแแก แแฆแแแกแแฉแแแแ, แ แแแแแแแช แฉแแแ แจแแแแฎแแแ. แแแฃ, แแก แแ แแก แแแ แฆแแแแแแ, แ แแแแแแแช แจแแแซแแแแ แแแแแฌแแแฃแแ แแงแแก แแแกแแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแแก แจแแชแแแแแ, Postgres-แแก แจแแชแแแแแแแ, Linux-แแก แแแ แแแแก แจแแชแแแแแ แแ แขแแฅแแแแแก แแ แแแแแแแแแ. แแ แแแแแแแแแก แฌแงแแ แแแแแก แกแแแแแแ แแ แชแแแ แฉแแแแแแแแแแ, แ แแแแแแแกแแแแกแแช แฉแแแ แแแแแแแแแแแแ.
แแแแ แแ แแแแแฅแกแแแแก แแแ แแ, แแ แแก แแกแแแ แแแฌแแแ, แ แแแแ แแชแแ แแ แแแ, แแแฃ แแแแแแ, แกแแแแช แแแแแชแแแแแ แแแแฎแแแ. แแ แแ แแ แแก แแแแ แ แฃแชแแแแแ, แ แแแแแก แจแแแแฌแแแแแช แจแแแซแแแแแแ.
แฉแแแ แแแแฅแแก แแแคแแ แแแแแ แกแแฎแแแฌแแแแแแ Heapcheck. แแแแแฌแงแแ แแแกแ แแแแแแแแ แแแ. แแ แแแ แแแแแฃแ แแ แฉแแแแแแ แแ แแแ แแแแแแแแ EnterpriseDB-แแแช แแแแฌแงแ แแแแฃแแแก แฌแแ แ, แ แแแแแกแแช แแแแแแแแฃแ แแ แฃแฌแแแแก Heapcheck. แแฎแแแแ แฉแแแ แแฃแฌแแแแ แแแก PgHeapcheck แแ แแแ แฃแแ แแแแ แแแแ แฅแแแก Heapcheck. แแฅแแ แแกแแแแกแ แคแฃแแฅแชแแแแแ, แแแแแ แแแแกแฎแแแแแแฃแแ แฎแแแแแฌแแ แแ, แแแแ แแ แแแแแ แแแแแแแ. แแแแแ แชแแขแ แฃแแแ แแฎแแ แชแแแแแแแแแ. แแ แแแ แแแ แ แแแแแแฅแแแงแแแก แฆแแ แแแแแ.
แแฎแแ แแ แฉแแแ แแแแแแแ แแแ แแแ แแแคแแ แแแแแแก, แ แแแแแ แแก แแฆแแ แแ แแก แแแแ แแแคแแ แแแแแ, แแ แแแแ แกแแแแแแแแแแแก แแแคแแ แแแแแ. แแ แกแแแแแแแแแ, แแก แแ แแก แแแ แแแแก แแแฌแแแ, แ แแแแแแช แแแแฌแแแแแ แงแแแแแก, แ แแแ แแแ แฌแแแแกแฌแแ แแชแแแแแ แแแแแแแแ แแ แแแแแแแแแก แจแแกแแฎแแ.
แแแแแ แแแแแแแ แแ แแแกแแแแแแแแช, แ แแ แแแแแขแแ แแแแแก แกแแกแขแแแแแจแ แแแแฅแแก แชแ แฃ แแแแแแแแ. แแแแแแแแแ, 1C แกแแกแขแแแ. แแแแแชแแแแ แแแแแก แแแแแงแแแแแแกแแก Postgres แแแแฏแแ แฌแแ แก แแแกแจแ แแแแแชแแแแแก, แ แแแแแแ แฌแแแแแฎแแแช แจแแฃแซแแแ, แแแแ แแ pg_dump แแแ แฌแแแแแแฎแแแก.
แแก แกแแขแฃแแชแแ แแแ แฃแคแชแแแก แฐแแแแแ แฉแแแแ แแ แแแแแแแแแก แแแแแแแแแแก แกแแกแขแแแแก. แแแ แแแ แแแแฆแแแซแแก. แแแ แแแแ แจแแฎแแแ แ แ แฎแแแแแแ. แแแ แแแแฃแแ แแแ แแแแแก แจแแแแแ แแแแแแขแ แแแแแแ แแ แแแแฎแ แ, แ แแ แแ แแแแแแแแ แแแฅแแก. แแแแกแฌแ แ แแฃแฎแกแแ แ แ แแ แแแแแแ แแงแ. แแแแ แแ แแ แแแแแแ แแแกแขแแ แแกแแก แแแ แแแจแแ.
แแแแแแ แแแกแแฃแกแแ แแ แแแฎแแกแแแแแแแแก แจแแกแแฎแแ. แแ แแแ แแแฌแแ แ, แ แแ แฉแแแ แจแแแแฎแแแ แแก แแแแกแแแ แแ แฃแกแแแแแแแ แแงแ, แแแแแแแแ แฆแแแแ แแแแฆแแแซแ, แ แแแ แแแแ แแแแ แ แ แแงแ.
แกแแแแแแแแแแแ แฃแแแกแฃแฎแ: โแแฐ, แฉแแแ แแแแแแแแแ แฃแแแ แแแแแแแกแฌแแ แแ แแก.โ
แแแ แขแแแ แแแแแแแ แแแฅแแก. แแฃ แคแแฎแกแแชแแแแ แแแแแฎแแ แ, แ แแแแแกแแช แฅแแแจแแก แแแ แชแแแแ แแฅแแก, แแแจแแ, แแ แแแชแแแจแ, แจแแแแซแแแแ แแแแแแแแแแแแ - แแ แแแแแแ แแ แแ แแก. แแฃ แฉแแฅแแแแก แงแแแแ แแแแกแแแแ แแแแแแแแก, แแแจแแ แแแแแ, แฉแแฅแแแแ แกแแแ แแแ แฅแแแจแแก แแแ แแจแ แแแแแแแแแ. แแ แแฃ แแฅแแแแ แคแแฎแกแแชแแแแก แแ แ-แแ แแ แแแแฎแแแ แแแแแ แแแแ แแแก แแแ แแแแแแ แแแ แแแแแก, แแแจแแ แแกแฃแ แ แแแแแแแแ แซแแแแแ แแแ แแ แคแแฎแกแแชแแแแ แแ แจแแแแแ แแแแคแแ แแแแแ แแกแแแ แแฅแแแแก แงแแแแ แแแแฎแแแ แแแแแแ. แแ แแกแแแ แแแฃแแแแแแแ แแแแฎแแแ แแแแแแ แงแแแแแแแแก แฆแ แฃแแแแแแ แแแ แแแแจแ แแ แแแ. แงแแแแแแแแก แแ แแแ แแแแฎแแแ แแแแแแ, แ แแแแแแแช แแงแแแแแแ แแแแกแขแแ แก แแ แแแแแแแฃแ แ แแแแ. แแแแกแแแแแก แงแแแแแแแแก แฃแแแ แแแแแแแแแ.
แ แ แแแกแฌแแแแแ แแฅ? แฉแแแ แแแ แขแแแ แ แแ แแแกแฌแแแแแ: แแแแแแ แแ แกแแแแแแแแแแแก แแแฃแฎแกแแแ, แ แแ แแ แแแแแแ แแ แกแแแแแก. แแฃ แกแแแแแแแแแแแ แแฆแแแ แ แแ แแแแแแ, แแแจแแ แแฃแแแแ แแแ แแแแแฃแ แแแชแแ แฌแแ แแแแฅแแแแแ แแ แแแแแแแก แแแแแกแแญแ แแแแ. แ แแแแแ แงแแแแแก แกแฃแ แก แแแแจแแแแแแแแแ แแ แแแแแแแก แแแแแญแ แ. แงแแแแ แแแแงแแแแแแก, แงแแแแ แฐแแแแ แก แแกแแแก, แ แแ แแแ แแแแแ แจแแฃแซแแแแ แแ แกแแแแแแกแแแแ แแแแแแแแ, แแแแขแแ แกแฃแ แ แแแแ แแฆแแแคแฎแแ แ.
แแฃ แแฅแแแ แแฃแจแแแแ แแ แแแแแแแแ, แแแแ แแ แแก แแฅแแแแก แแแ แแ แแ แแแแก แแฌแฃแฎแแแก, แแแแ แแ แกแแกแขแแแแขแฃแ แแ แแฃแจแแแแ แแ แแก แกแแแแแแแ แแ แแแแแแแ แแแแแแแ, แแแจแแ แแฅแแแแ pull แแแแฎแแแแ แแฃแชแแแแแแแ แแแแฆแแแ. แแฅแแแแ แแแขแฉแ แแแแฆแแแ, แแฅแแแแ แแแฃแแฏแแแแกแแแแแ แแ แแฃแแแแช แแแฃแแฏแแแแกแแแแก แแแแฎแแแแแแ แแแแแฎแแแแแ แกแแแแแแแแแแแก แแแแ . แแฆแแก แแแแแก, แฉแแแ แแแฃแแฏแแแแกแแแ แแแแแชแแแแ แแแแแก แแ แแแแแแแแกแแแแก.
แกแแแแขแแ แแกแ แแแแแชแแแแ แแแแแ Greenplum. แแก แแ แแก แฃแแฆแ แแกแแ แแแ แแแแแฃแ แ แแแแแชแแแแ แแแแ, แ แแแแแแช แแแคแฃแซแแแแฃแแแ Postgres แแแแแแแก แแแแแแ, แ แแแแแกแแช แแแ แแแ แแแชแแแ.
แฎแแแ Greenplum-แก แแฅแแก แกแแแแขแแ แแกแ แคแฃแแฅแชแแแแแ แแแ - แแแฃแ แแแก แแแขแแแแแแ แแแฃแแ แชแฎแ แแแแแ. แแก แแ แแก แชแฎแ แแแแแ, แ แแแแแแแช แจแแแแซแแแแ แกแฌแ แแคแแ แแแแแแขแแ. แแกแแแ แจแแแซแแแแ แแงแแก แกแแแขแแแแแ แแ แแฌแแ แแแ.
แแแแ แแ แแ แแงแ แแแแกแขแแ แแ แแแ, แแแฃ แแ แแงแ แคแฃแแฅแชแแแแแ แแแ, แกแแแแช แจแแแแซแแแแ แแแแฌแงแแ แชแฎแ แแแจแ แแแแแแแกแแแฃแแ แแแแแชแแแแแ แแ แแแแแแแแแแ แแแแก แจแแกแแแแแแกแแ, แ แแแแแแช แแ แแก แแ แ-แแ แ แแแแแฅแกแจแ.
แขแแฅแกแแแแ แแแญแแแ แแแแแแแแ แฉแแแแแ แแ แแแแฎแ แแก: โแแแแ แแ, แจแแ แแชแ แแแกแขแแ แแกแ. แแ แแฅแแช แแแแฅแแแก แแแแแแ. แแแแแ แแแ 20 แฌแฃแแแ. แจแแ แแแฆแ แแ แแแแแแแโ. แแ แแแคแแฅแ แ, แ แแ แแแแฎ, แแ แแแชแ แแแกแขแแ แแกแ, 20 แฌแฃแแแก แแแแแแแแแแแจแ แแแแแ แแแ - แแก แฃแแแ แแแแแแแแ.
แแแแ แแ แแ แ, 20 แฌแฃแแ แแ แแงแ, แแแแแแแก แแแแแแแแแแแจแ แแแแฌแแ แ. PgConf.Russia แแแแคแแ แแแชแแแแ แแ แแแแฃแแฎแแแแแ แฐแแแแ แแแแแแแแแแกแก Pivotal-แแแ แแ แแแแแฎแ: โแแฅ แ แแแแ แแ แแแแแแแ? แ แแขแแ แแ แแ แแก แแแแแขแแแฃแแ แชแฎแ แแแแแแก แแแขแแแแแแแฃแแ แแแแกแขแแ แแ แแแ?โ แแก แแแแแแก: โแแฅแแแ แแฆแแแ แแแแแชแแแแแก. แแฅแแแ แแแแแแแแแ, แแฅแแแ แแแแแแฌแงแแแ. แแก แฃแแ แแแแ แกแแแฃแจแแแโ. แแ: "แแฐ, แแแแฎ, แแฅแแแ แฃแแ แแแแ แฃแแแ แแแฆแแ แแ แแแแแแแแ แแก." แแก แแแแแแก: โแแแแฎ, แฉแแแ แแแญแแ แแแแ แแแแแกแฃแคแแแ แฎแแแแแ แแแแก แแแกแแแแแแแแแโ. แแคแแฅแ แแแแ, แ แแ แแก แแฃแชแแแแแแแ แฃแแแ แแแแแแแแ.
แแ แ แแแแแแแแ แแแแก แจแแแแแ แแ แฌแแ แแแแแแแ แแแงแแแแแก แแแแฎแแแแ, แ แแแแแแช แแฎแแ แชแแแแแแแ แแ แคแฃแแฅแชแแแก. แแก แแแแฎแแแแ แแแแแฎแแแ Pivotal-แแ แกแแแแแแแแแแแกแแแ แแ แแแ. แ แ แแฅแแ แฃแแแ, แแงแ แจแแชแแแแแแ.
แแแแ แแ แงแแแแแแ แกแแแแขแแ แแกแ แแก แแ แแก, แ แแ แ แแแแกแแช แแก แแแแฎแแแแ แแแแ แแแแแแ, แจแแชแแแแแแ แแฆแแแแฉแแแแก แแแแแ Greenplum-แจแ. แฉแแแ แแฆแแแแแฉแแแแ, แ แแ แแ แแแแก แชแฎแ แแแแแ แฎแแแแแฎแแ แแ แฆแแแแก แขแ แแแแแฅแชแแแก แแแแกแขแแ แจแ. แแ แแก แแ แแก แกแแแแแฎแ, แ แแแแแแช แฃแแแ แแแแแกแฌแแ แแแก. แแ แแก แแ แแก แแ แแแแแแแก, แ แแแแแกแแช แแ แแฎแแแฎแแ แจแแแแฎแ. แแ แฉแแแ แแฃแแแแ แแแ แ แแแฅแชแแ แแงแ - แแแ แแ, แแแแ แแแแแชแแ แแแช แแแแแแแแ แแก.
แแแแแแแกแฌแแ แ แแก แจแแชแแแแ. แแแฃแแแแแแ แแแงแแแแแก แแแแฎแแแแ แคแแฅแกแแขแแ แแแก. แฒแก แแแแแฃแ แแฅแแ.
แ แแก แจแแแแแแแช แแแแ แแแ, แ แแ แแก แคแฃแแฅแชแแแแแ แแแ แกแแญแแ แแ Greenplum-แแก แแแ แกแแแจแ PostgreSQL 12-แแกแแแแก. แแแฃ 20 แฌแฃแแแแแ แแแแแแแแกแแแแแ แแ แซแแแแแแ แแฎแแแ แกแแแแขแแ แแกแ แแแแแแแแกแแแแแแแ. แกแแแแขแแ แแกแ แแงแ แแฆแแแแแแแ แแแแแแแแ แแแแแ แจแแฎแแแ, แกแแแแช แกแแแแแแแแแแ แแฎแแ แแ แงแแแแแแ แแแแจแแแแแแแแ แคแฃแแฅแชแแแแก แญแ แแก. แแแงแแแฃแแแ.
แแแแ แแ แแก แแ แแแกแ แฃแแแแฃแแ. แงแแแแแแแ แแแแก แจแแแแแ แแฆแแแฉแแแ, แ แแ แแ แงแแแแแคแ แแกแแแแก แแแแฃแแแแขแแชแแแก แแแฌแแ แ แแแญแแ แแแแแแ.
แแแแแฌแงแ แแแแฃแแแแขแแชแแแก แฌแแ แ. แกแแแแแแแแ แแ, Pivotal-แแก แแแแฃแแแแขแแแแกแขแแแ แแแแแแแแ. แแแแแแกแฃแ แ แแแแ แแจแแแแแฃแ แ แแแแ. แแแแฃแแแแขแแชแแแจแ แแแแแฎแแแ แแแ. แกแแแแแแแแแแจแ, แแแ แแแแแ แแแแแฌแแ แแก แแก, แ แแช แแ แจแแแแแแแแ แ แแแแฃแ แแแแแแกแฃแ แแ.
แแ แแฅ, แ แแแแ แช แฉแแแก, แแแแแแแแกแแแแแ แแแกแ แฃแแแ. แแ แแชแ แ แ แแแฎแแ แแแ แ? แขแแฅแกแแแแ แแแญแแแ แแแแแแแแ แฉแแแแแ แแ แแแแฎแ แแก: โแฏแแ แแแแแ แแ แ โโแแแแแแแแกแแแแแแ, แแแแแแฃแแ 10 แฌแฃแแโ. แแ แ แ แฃแแแ แแฃแแฎแ แ แแแ? แแ แแฃแแฎแแ แ, แ แแ แแฎแแ แแ แแแแชแแแ แแแฎแกแแแแแแก แแแกแจแขแแแแ, แจแแแแแ แแแแฎแแแ แแฅแแแแก แแแแแแแแกแแแแแแก, แ แแแแแ แแก แกแแแแขแแ แแกแ แกแแแฃแจแแแ.
แ แ แแแกแฌแแแแแ แแ แจแแแแฎแแแแแแแ? แแแแก แแแแ, แ แแ แฆแแ แแแแแ แแฃแจแแแแ แงแแแแแแแแก แแ แแก แแแแแ แแขแฃแ แแแแแแแแแแ แแฃแจแแแแ, แแก แงแแแแแแแแก แแฃแจแแแแก แกแแแแแแแแแแแกแแแ. แแแแขแแ, แ แแ แงแแแแ แแขแแแแ แแแฃแจแแแแแ แ แแแแแแแ แแแแแแแแแ แแแ, แแแแแแ แ แขแแกแขแแ แแแ, แแแแแแ แ แฐแแแแ แแแ, แแแแแแ แ แแแแฃแแแแขแฃแ แแแ, แแแแแแ แ แแ แฅแแขแแฅแขแแ แแแ. แแ แแ แแแฃแจแแแแแ Greenplum-แแแ, แแแฃแจแแแแแ Greenplum-แแก แแแ แจแแแ แแงแแค แแแแแแแแแแแแ.
แแแแ แแ! แแ แแก แแแแแ แแ แแ แแแแจแแแแแแแแแ แฌแแ แขแแแ - แแก แฃแแ แแแแ แกแแแฃแจแแแ. แแแฃ แแแแแฎแแ , แงแแแแก แแแแแ, แแแแก แฌแแ . แงแแแแ แกแแฎแแก แแแ แขแแแ แฃแชแแแแแ แแฃแจแแแแก. แแแแแแแ แแแ แแแแฃแ แแ - แแแ แแแ แแฅแแแแ! แแ แกแแแแแแ แกแแแแขแแ แแกแ แกแแแฃแจแแแ. แแ แกแแแฃแจแแแก แแแแฎแแแแ แแ แกแแแแแก Yandex.Cloud แแแแแแขแแแแกแแแ, แฉแแแแ แแแแกแขแแ แแแแก แแแแฎแแแ แแแแแแแกแแแ, แ แแแแ แช Yandex-แแก แจแแแแแ, แแกแแแ แแแก แคแแ แแแแแก แแแ แแ. แแ แแคแแฅแ แแ, แ แแ แแแแแ แแแแ แแ แแแฅแขแแแแก แ แแแแแแแแ, แ แแแแแจแแช แฉแแแ แแแแแแฌแแแแแแ แแ แแแแแ แแแแ แฉแแแแ แฉแแ แแฃแแแแแก แกแแฆแ แแแช.
แฒกแฃแ แแก แแ แแก. แแแแแ แแแแแแแแแ แแแแฎแแแแแ.
แแแแฎแแแแแก แกแแกแแ
แแแแแ แฏแแแ! แแแแฅแแก แแแแแ แแ แแ แแแแฎแแ-แแแกแฃแฎแแก แกแแกแแ. แแ แกแขแฃแแแแจแ แแแแ แแ แแแ แแแแแ. แแก แแก แแแแแแแแแ, แ แแแแแแแช แแฎแแแฎแแ แแแแฎแ แ Yandex.Cloud-แแกแ แแ Yandex-แแก แฌแแแแแแก แจแแกแแฎแแ แฆแแ แฌแงแแ แแจแ. แฉแแแแ แแแฎแกแแแแแ แแฎแแ แแแแแแแแ แแ แแ แแก Cloud-แแก แจแแกแแฎแแ, แแแแ แแ แแแแแ แแ แแก แฉแแแ แแแคแฃแซแแแแฃแแแ แแกแแ แขแแฅแแแแแแแแแแ. แแแแก แแแ แแจแ, แ แแช แแฅแแแ แแแแแแแแ Yandex-แจแ, Yandex.Cloud-แจแ แกแแ แแแกแ แแ แแฅแแแแแแ, แแแแขแแ แแแแแแแ แแแ แแแแ แฉแแแแแ. แแ แแแ แแแแ แจแแแแแฎแแ แแแแแชแแแแแแ: "แ แแแแ แแแฌแแ แแแ แแแแแแฃแแ แแ แแแฅแขแ, แ แแแแแแช แแฅแแแ แแฎแกแแแแ?"
แกแแ แแแแ แแ แกแแกแขแแแ WAL-G-แจแ แแฌแแ แแแ Go-แจแ. แแก แแ แแก แแ แ-แแ แแ แแฎแแแ แแ แแแฅแขแ, แ แแแแแแแช แฉแแแ แแแแฃแจแแแแ. แแก แคแแฅแขแแฃแ แแ แแฎแแแแ 3 แฌแแแกแแ. แแ แแแแแชแแแแ แแแแ แฎแจแแ แแ แแฎแแแ แกแแแแแแแแก. แแ แแก แแแจแแแแก, แ แแ แแแแแชแแแแ แแแแแแ แกแแแแแแ แซแแแแแ แแ แแกแแแ แฉแแแฃแแแแ แแ แแฌแแ แแแ C-แแ. Postgres-แแก แแ แแแฅแขแ แแแแฌแงแ แแแแฎแแแแแแ 30 แฌแแแก แฌแแ. แแแจแแ C89 แแงแ แกแฌแแ แ แแ แฉแแแแแ. แแ แแแกแแ Postgres แฌแแ แแ. แฃแคแ แ แแแแแแแแ แแแ แแแแแชแแแแ แแแแแแ, แ แแแแ แแชแแ ClickHouse, แฉแแแฃแแแแ แแ แแฌแแ แแแ C++-แจแ. แกแแกแขแแแแก แงแแแแ แแแแแแแแ แแแ แแคแฃแซแแแแ C แแ C++-แก.
แจแแแแแฎแแ แฉแแแแ แคแแแแแกแฃแ แ แแแแแฏแแ แแกแแแ, แ แแแแแแช แแแกแฃแฎแแกแแแแแแแแ Cloud-แแก แฎแแ แฏแแแแ: โแ แแขแแ แฎแแ แฏแแแก Cloud แคแฃแแก แฆแแ แฌแงแแ แแก แแฎแแ แแแญแแ แแแ?โ
แแฅ แแ แแก แแแ แขแแแ แแแกแฃแฎแ แคแแแแแกแฃแ แ แแแแแฏแแ แแกแแแแก. แฉแแแ แแแแก แแแแแแแแ แฉแแแแ แกแแ แแแกแแแแก แแแกแแฃแแฏแแแแกแแแแแ. แ แ แแแแแแ แจแแแแแซแแแ แแแแแแแแแ แฃแแแแแกแ? แฉแแแ แจแแแแแซแแแ แแแแแแแแแ แกแแฅแแแแแ แฃแคแ แ แแคแแฅแขแฃแ แแ, แกแฌแ แแคแแ แแ แแแแฎแแแแ แงแแแแแคแแ แ แฃแคแ แ แแแกแจแขแแแฃแ แ. แแแแ แแ แฉแแแแแแแก แแก แแแแแแ แแแ แแแ แ แแแจแ แกแแแแแแแแก แแฎแแแ. แแแแแแแแแ, แกแแ แแแแ แแ แกแแกแขแแแแจแ แฉแแแ แแแแแแฎแแแแแ แแแขแฉแแแแก 100%-แก, แ แแแแแแแช แแแกแแ แแ แชแแแแแแ. แฉแแแ แแแชแแ แ แ แแ แแก แแแแ. แฉแแแ แฃแคแ แ แแแแคแแ แขแฃแแ แแแ แ แแฎแแแ แแแ แกแแแแแก แฌแแ แแแแแแจแ แแแแแจแแแแแจแ. แแแฃ, แแแ แแแ แ แแแจแ, แกแแฃแแแ แแ แแแแแแแ, แแแแแแแแ แแแแกแแแแก แแแแแงแแคแแแแ แแ แกแแแแแแแแแแแ
แแแแแ แแ แแ แจแแแแแฎแแ: โแแแแกแฎแแแแแแแ แแฃ แแ แ Yandex.Cloud-แจแ แแชแฎแแแ แแแ แแแ แ แแแแฎแแแ แแแแแแแก แแแแฎแแแแแแ แจแแแ Cloud-แจแ แแชแฎแแแ แแแ แจแแแ แแแแฎแแแ แแแแแแแกแแแ?
แแแขแแแ แแแแก แแ แแคแแแ, แ แ แแฅแแ แฃแแแ, แแแแกแฎแแแแแแฃแแแ. แแแแ แแ แฉแแแ แแแแงแแคแแแแแแก แแแแแกแแแ แแกแแ แงแแแแ แแแแกแแแฃแแ แแแฃแแ แแ แกแแแแขแแ แแกแ แกแแฅแแ แแฅแแแแแ แแ แแกแขแแแแแ แขแฃแ แแแขแแแ แแแแแ. แฌแแ แแแกแแฎแแแก แฃแแแ แแก แแฅแแแ แแแแแแแแแ แแแ, แแแแแแแแแ แแแ, แ แแแแแแแช แแแแแแแแ แแแฃแแแแแแแก, แ แแแแ แช แจแแแแแแแ, แแกแแแ แแแ แแแแฃแแแ, แ แแแแ แช แฉแแแก, แแแฎแแแแแ. แแ แแฎแ แแ, แฉแแแ แงแแแแแแ แแแแฎแแแแแแ แแ แแแแแ แแแ แแแ แ. แแ, แแแแแ, แแแแแชแแแแ แแแแแแแก Yandex-แแก แแฃแจแแแแแก แแ แแแแแ แแ แแแแจแแแแแแแแแ แคแฃแแฅแชแแ แแฅแแแแ แแก, แ แแ Yandex-แแก แจแแแแแ แแแแฅแแก แกแฌแแแแแแ. แ แแฆแแช แแแแแแขแจแ, แแแแแแ แแ แฎแแแแแกแแฌแแแแแแแแก แแแแ แแแแแแแแ แแแแแแแก แฉแ แแแแจแ แแ Yandex-แแก แงแแแแ แกแแ แแแกแ แ แแแแ แแ แฃแแแ แแแแแ แซแแแแก แคแฃแแฅแชแแแแแ แแแ แแแแก แแแฃแฎแแแแแแ. แแก แแชแแ แ แแแแกแฎแแแแแแแ. แแแแ แแ แแก แฅแแแแก แฃแแแ แแ แแแแแแแก แแแแแแแแ แแแแก แแแแแชแแแแ แแแแแก แแ แฅแกแแแแก แกแขแแแแก แแแขแแ แคแแแกแจแ. แฌแแแแแฆแแแแ แจแแแแฎแแแแแจแ, แแแ แ แแ แจแแแ แแแกแขแแแแชแแแแ แฌแแ แแแฅแแแแแ แแ แแกแ แแ แแแแแ แแแแฎแแแแแก แคแฃแแฅแชแแแแแ แแ แแแแแแแแฃแ แแแแฎแแแแแแก แกแแแแแแแแแแกแ แแ แจแแกแ แฃแแแแแก แแแกแแฃแแฏแแแแกแแแแแ.
แจแแแแแแ แจแแแแแฎแแ: โแแแ แแแแ แแฅแแแ แ แแแแ แคแแฅแ แแแ แแ แคแแฅแขแแ, แ แแ แ แแกแแช แแแแแแแ แกแฎแแ แฆแ แฃแแแแแแก แแแแ แแแแแแงแแแแแ? แฉแแแ แแ แแแแแกแแฎแแแแแ แแแแแ แแขแฃแแก, แแแแ แแ แแแแ แ แแ แแแฅแขแ, แ แแแแแแช แจแแกแ แฃแแแ Yandex.Cloud-แจแ, แแแแแแงแแแแแ แกแฎแแ แแแแแแแแแแแก แฆแ แฃแแแแแจแ.
แฒแก แแแแแ แแ. แฏแแ แแ แแ, แแก แแแแก แแแจแแแแ, แ แแ แ แแฆแแช แกแฌแแ แแ แแแแแแแแแ. แแ แแก แแคแแ แฎแแแก แแแแก. แแ แฉแแแ แฃแคแ แ แแแ แฌแแฃแแแแฃแแ แแแ แ, แ แแ แกแฌแแ แ แแแแแฌแงแแแขแแแแแ แแแแแฆแแ. แแแแ แแก แแฎแ แแ, แแก แแ แแก แแแแแ, แ แแ แแแแแแแแจแ แแก แแแแแแขแแแก แแฎแแ แแแแแแก, แแฎแแ แแแแฎแแแแแแก แแแกแแแ แแฎแแ แแก แแแแฎแแแ แแแแแแแกแแแ. GitHub-แแ แแ แแแแแแแแแก แฃแแแขแแกแแแ แแฅแแแแแ แแแแแแแแฃแแแฃแ แ แกแแกแขแแแแก แแแแแแแกแขแ แแขแแ แแแแก, แแแแแแแแฃแแแฃแ แ DBA-แแแแก, แแแแแแแแฃแแแฃแ แ แแ แฅแแขแแฅแขแแ แแแแก, แแแแแแแแฃแแแฃแ แ แแแแแแ แแแแก แแแแ , แแแแ แแ แแแแฏแแ แแแแแแ แกแแกแขแแแแขแฃแ แ แแแแแชแแแแแแแก แแฅแแแ แแแแแแแแแแ แแ แแแแแแแ, แ แแ แแแ แแแแฃแแ แจแแแแฎแแแแแแแก 30% -แจแ แแแแฅแแก แแก แแ แแแแแแ แแ แแแแ แแแคแแฅแ แแ แ แแแแ แแแแแแแแ แแ แแแ. แแก แแ แแก แแก, แ แแกแแช แฉแแแ แงแแแแแแ แแแขแแ แแแแแแแแแ. แฉแแแ แแแฃแแแแแแแ แแแแแ แแแแแชแแแแแแแก แแแแแแ แแแแก แกแฎแแ แฆแ แฃแแแแแแ แแแแขแคแแ แแแแแแ.
แแฅแแแ แแแแ แ แแกแแฃแแ แแ แแแ แแแแแแ. แแแชแ, แ แแ แแแกแแแแจแ แแแ แแแแแ แแแแ แแแแแ. แฒ แแแแ แช แจแแแแแ? แแแแแฃแกแฌแ แ แแแญแแแก PostgreSQL-แแแ?
แแ แ, แแแแ แแแ แขแฃแแแแ แซแแแแแ แกแฌแ แแคแแ แแแ แแแก. แแแ แฉแแแแ แแ แแ แกแแแแแ แแแ แ แแแแกแ แฃแแ. แแแแแแแแแแจแ, แแแแงแแคแแแ แแแ แแแแ, แแฃ แ แแแแแแแ แจแแ แก แแแแแแ. แฉแแแแแแก แแฎแแแแ แแแกแ แฃแแแแ แแแฆแฌแแแ แแงแ. แกแแแ แแ แฏแแแจแ, แแแกแแแแแ แแ, แ แแ แแแกแขแแ แแก แกแแแแแแแแแแแจแ แแแแแแ แแแ แแแแแแแ. แแแฉแแแแแแ, แ แแ แแ แกแแแแแก แแแ แแแแฃแแ แแแแจแแ แ แแแ แแแฃแ แกแแแ แขแกแ แแ แกแแกแขแแแฃแ แ แแ แแแ แแแแ แแแแก แกแฃแ แแแแก แจแแ แแก.
แแฅแแแ แแแแแแ, แ แแ ClickHouse-แจแ แแแ แแแแแแ แแ แแ แแก?
แแฃแกแขแแ แแแชแ, แ แแ แแฅ แแ แแแ. ClickHouse แแกแแแ แแ แแก แแแแแชแแแแ แแแแ. แกแฎแแแแ แจแแ แแก, แแแแแ แแฎแแ แแฌแแ แก: "แแแฎแกแแแแแแก แจแแแแแ แฌแแแแแแ แกแแ แแแแแ?" แแก แจแแกแแแแจแแแแ แแแแแ.
แแแแแ แแ แแ แจแแแแแฎแแ แแแแแขแแก แแแแแชแแแแแแ: โแ แแขแแ แแแแแแกแฌแแ แ แฎแแ แแแแ Greenplum-แจแ แแ แแ แแฉแฃแฅแ แแแ แฃแแชแ แแกแแแก?โ แแแ แแแแแ, แแ แช แแกแ แแแแแแแ, แ แ แแ แแก แจแแชแแแแ แแ แ แแแแ แกแแ แแแกแจแ, แแแแ แแ แแก แแแแแ แแแแก แแแจแแแแก, แ แแแแช แแฅแแแ แแกแแฃแแ แแ.
แแ, แแ แแแชแแแจแ แจแแแซแแแแแแ แแแแแแกแแแแก แแแแชแ. แแก แแฎแแแแ แแแแ แแงแ, แ แแแแแแช แแฎแแแฎแแ แจแแแชแแแแ. แแ แแฃแแแแ แแแ แแงแ แแแแก แแแแ แซแแแแแ แแแจแแแแ. แแ แแแชแแแจแ, แแฃแแแแแ แแแแแชแแแแแแแก แแแแแแ แแแแก แแแแ แแแ แแ แแแแแ. แฉแแแ แแฃแชแแแแแแแ แแแแฃแแแแ แแแ Greenplum-แแก แแแแชแแแแแก แฉแแแแ แแแแงแแคแแแแแแก แงแแแแ แฌแแแ แก แจแแ แแก.
แแแแแแแแ แฉแแแ แแกแแฃแแ แแแ แแฃแแแแ แแแแ, แแฅ แแ แแก แจแแแแแฎแแ. แแแแแแแแแ แแแแแฌแงแแแขแ แแแ แแแแ แแแแแขแแก แจแแฅแแแ แแแกแขแแ แแกแจแ. แ แ แฃแแแ แแแแแแแแก แแแ แแแ แแแแ แแแแแแแฃแแแแแก แจแแกแแกแ แฃแแแแแแ?
แแก แแ แแก แกแแแแขแแ แแกแ แแแแฎแแ: "แกแแแแแ แแแแแฌแงแแ?" แฉแแแฃแแแแ แแ, แกแแแแแแ แ แแฃแแแ แแแ แแแจแ แ แแฆแแชแแ แแแฌแงแแแ. แแแแแแแแแ, Postgres-แจแ แแ แแก แแแกแแแแแแแแแ แกแแ. แกแแแแแแแแแแจแ, แแก แแ แแก แคแฃแ แชแแแ แแแแกแ, แ แแกแ แแแแแแแแแช แแแ แกแชแแแแก, แแแแ แแ แแ แแแแแฃแแแแแ. แแก แแแแแแแฅแกแฃแ แ แกแแแแแแแ. แแ, แ แแแแ แช แฌแแกแ, แจแแแแซแแแแ แแแแแแ แ แแแแแแแแ แแแแฃแแแแฃแ แ แแ แแแ แแแ แแแแกแแกแขแแแแจแ, แแแแแแ แแ แแแคแแ แแแแแ, แ แแแแแแช แจแแแซแแแแ แแแฃแแฏแแแแกแแแก, แ แแช แแแแแแ แงแฃแ แแแฆแแแแก แแแงแ แแแก แแแ แแแแก แแแแแแแแแ แแแแกแแแ. แแ, แจแแกแแแแแแกแแ, แแฅ แฃแคแ แ แแแขแ แแฃแแฅแขแแ แแ แแแกแแแแก. Google Summer of Code แแ แแแ แแแแแ แงแแแแแฌแแแฃแ แแ, แแแกแขแแ แแกแแก แกแแแแแแแแแแ แแงแแแแแก แแ แแแแ แแแแกแฎแแแแแแฃแ แแแแแก, แ แแแแแแ แแแแฎแแแแแช แจแแกแแซแแแแแแแ. แฌแแแก, แแคแแฅแ แแ, แกแแแ แกแขแฃแแแแขแ แแแงแแแแ. แแ แแแ WAL-G-แจแแช แแ แแแฌแแ แ Yandex-แแกแแแแก แแแแจแแแแแแแแ แแแแแแแ. Greenplum-แจแ แงแแแแแคแแ แ แฃแคแ แ แแแ แขแแแแ, แแแแ แ Postgres-แแก แกแแแแแแแแแแแจแ, แ แแแแแ Greenplum-แแก แฐแแแแ แแแ แซแแแแแ แแแ แแแ แแแงแ แแแแแ แแแแฎแแแแแแก แแ แแแฃแงแแแแแแแแ แแฌแงแแแแ แแแแฎแแแแแก. แแแกแขแแ แแกแจแ แแแฉแแก แแแแแแแแ แแแแแแแก แกแแแแแฎแแ, แแแแ แแ แแ แแแแแฃแแ แแ แ แแฆแแจแ แแแแ แแ แแแฎแแแก แ แ แแแแแแแ. แกแฎแแ แกแแฅแแแ, แ แแ แแ แแแแแฃแแก แกแญแแ แแแแ แแ แกแแแฃแแ แแ แแแแแแแแแก แแแแแญแ แ. Greenplum แคแแ แแแ แแ แแแแแแงแแแแแ, แแแแขแแ แแฅแแแแ แแ แแแแแแแก แแแแแ แกแแแแแแ แ แแฃแแแ. แแ แฃแแแ แแแแแก แงแแแแแกแ, แฉแแแ แฃแแแ แแแแแแแแ แแ แแ แแแแแแแแ, แ แ แแฅแแ แฃแแแ.
แฌแงแแ แ: www.habr.com