แแแแแ แฏแแแ, แฐแแแ ! แแแแแ, แแแแแแฃแ แฉแแแแแแแก แแฅแแก แคแแแแ, แกแแแแช แฉแแแแแแแก แ แแฆแแช แกแแกแแ แแแแแ แแ แกแแแแขแแ แแกแแก แแแแแแแ. แแแแแแ แแ แแแฃแแ แกแขแแขแแแแแแ, แฌแแแแแแแแ, แกแแชแแแแแแแ, แกแแฎแแแแซแฆแแแแแแแแแแแ. แแก แจแแแซแแแแ แแงแแก แแ แแฃแแแ แแก แกแแแแจแแแแแ แแ แแฃแแแแช แแฎแแแแ แแแแแแแแแแแ แแแ แฉแแแแแ แฉแแแแ แแแแแก แแแฎแกแแ. แแ แแแ แแแแแแแแแแแจแ, แแก แงแแแแแคแแ แ แแแแแแแก, แแแฃแแแแ แฌแงแแแขแก แแแฎแกแแแก แแ แแแกแแแแแแก แฃแแแขแแกแแแ แฃแแ แแแแ แแแซแแแแแแฃแแแ.
แ แ แแแฎแแแแ, แแฃ แแ แกแแแแแแก แแแแฃแแแแ แแแ แกแแแแแแแแแแแก แแ แแแแแแแฅแแแงแแแแ แแ แคแแแแก GitHub-แแ? แแแจแแ แแฅแแแแ แแแแฃแจแแแแ แ แจแแแซแแแแ แกแแกแแ แแแแแ แแงแแก แกแฎแแแกแแแแก แแ แแฅแแแ แจแแแแซแแแแ แจแแแแแ แฉแฃแแแ แจแแกแแแแแแกแแแ แแ แแแ, แแแแฆแแ แแแแแฎแแแแแแ แแกแฃแ แแแแแแแกแแแ แซแแแแ แแแ แแ แแแแ แแก แกแแจแฃแแแแแแ. แกแฌแแ แแ แแแแกแแแแก แแ แแก แจแแฅแแแแแ แแ แแแฅแขแ.
แแ แแฅแแแ แแแฅแกแแ แแ แแแแแ. CROC-แจแ แแแแแแแ Java-แก แแแแแแแแ แแแแก แแ แแแแแชแแแแ แแแแแก แแแแแแแก. แแ แแแกแขแจแ แแ แแแขแงแแแ แ แ แแ แแก แแแกแแแชแแ แ แกแแแแ แแ แ แแแแ แแแแแแแแ แแฅแแแแ แกแแแฃแแแ แ แแคแแชแแแแฃแ แ แแแกแแแชแแ แ แ แแแ.
แ แ แแ แแก แแแกแแแชแแ แ แกแแแแ
แ แแแแกแแช แแฎแแแ แขแแฅแแแแแแแแก แแ แแ แแแ แแแแ แแแแก แแแแก แแแแแชแแแแ แแแฌแแแก, แแแ แแแแ, แ แแกแแช แแแแแแแ, แแ แแก แแฅ แฌแแกแแแ - แแแแแแ แกแฌแแ แ แแแแงแแคแแแแแ แแ แแแกแจแ แแ แแก แจแแกแแแแแแกแ แคแฃแ แชแแแแ. แแ แแฃ แแแแกแฏแแแแแ แแแ แกแแแแแแแแแก แ แแแแแแแแแกแ แแ แแแแ แแฃแแแแแ แแ แแแก แแแฎแแแแแ, แแแแก แแฎแแแแ แแ แแ แแแแแแแ.
แกแแแแแแแแแแจแ, แแก แแ แแก แฉแแแฃแแแแ แแแ แแแแ readme.md, แ แแแแแแช แชแฎแแแ แแแก แชแแแแ
แแแแแแ แ แแแแกแแแ แแก แแ แแก, แ แแ แงแแแแ แแก แคแฃแ แชแแแ แแแแฎแแแ แแ แ แแแ แแแแ แแแขแแ แแก, แแ แแแแ แกแแแแแแแแแแแก แแแแ แแ แจแแแแแแแแแ แกแแแชแแแแฃแ แ แแ แซแแแแแ แแแแชแ แ แฌแแกแแแแก แจแแกแแแแแแกแแ.
แแแแแ แแ แกแแฌแแ แแแก แแแแแก แแแขแแ แ แแ แแแแ แแแแแขแแ แ แแ แแก แแแแแแแแ แฃแแ แกแแแแ แ แกแแ แฐแฃแกแ,
แ แแแแ แแแฎแแแแ แแแกแแแชแแ แกแแแจแ
แแฃ แแแฃแแแแแแแแ แแแ แแแแแแแ แจแแกแแคแแ แแกแ แคแฃแ แชแแแ แแฅแแแแแแแก แกแแแแขแแ แแกแ แแแแแแ, แแแจแแ แแก แแ แแก แแแ แแแแ แแแจแแแ แแแแกแ, แ แแ แแฅแแแ แแแแแแ แฃแแแ แแแแแแแแ แแแ!
แแ แแแขแงแแแ แฉแแแ แแแแแแแก แแแแแแแแแ.
แ แ แกแแญแแ แแ แแแแกแแแแแก?
- แฉแแแ แแ แแแแกแขแ แแ แแแ แ แแแฃแแแ แฃแ GitHub แ แแแแก แกแแฎแแแแ, แ แแแแ แแชแแ awesome-whatever. แฉแแแก แจแแแแฎแแแแแจแ, แแก แแงแ แแแกแแแชแแ แ แแแแแชแแแแ แแแแ-แแแกแขแ แฃแแแแขแแแ
- แฉแแแ แแแแงแแแแ แ แฉแแแแ แคแฃแ แชแแแ แแแกแแแชแแ แคแแ แแแขแจแ, แแก แแแแแแฎแแแ แแแ
แแแแแ แแขแแ แ-แแแกแแแชแแ แ แกแแ , แ แแแแแแช แแแแแแแฃแจแแแแแก แงแแแแ แกแแญแแ แ แคแแแแก แกแแญแแ แ แคแแ แแแขแจแ - แ แแแแฃแ แ CI-แแก แแแงแแแแแ.
แแแกแแแชแแ แแ-lint แแ แขแ แแแแก แกแ แแแแแแฎแแแ แแแ แแแแขแ แแแจแแแแฅแแแแแแแก แฉแแแแ แคแฃแ แชแแแ - แแแแแแแแแ 30 แแฆแ
- แฉแแแ แแแแแแฎแแแแแ แกแฃแ แแชแแ แ 2 แกแฎแแ แแแแแแแแแก แแแแ แก
- แแ แแแแแก แแแแแแแแ แแแแ แก แแแแแแ แ แแแแแ, แกแแแแช แแแแแขแแแ แแแฃแแก แฉแแแแก แ แแแแแ. แแฅ แแฅแแแ แฃแแแ แฌแแแแแแฎแแ แงแแแแแคแแ แ แงแฃแ แแแฆแแแแ แแ แงแฃแ แแแฆแแแแ แจแแแกแ แฃแแแ แงแแแแ แแ แแแแแ แแชแฎแแแแแ แแแแฎแแแแ แแฎแแแ แคแฃแ แชแแแกแ แแ แแแแแ แแแแ แแกแแแแก.
แฉแแแ แแแ แแแแ แแแแแ
แแแแ แแ แชแแขแ แแ แ แแแแแแ, แแแแแ แฃแคแ แ แแแขแ แแแกแแแ แแแแแแ แแแ, แจแแชแแแแแแแ แแแแฃแจแแแ แแ แแแแแแแ
แแแแ แแ แแแแแแแฌแงแแ แซแแแแแ แแแแจแแแแแแแแแ แ แแ, แ แแช แแแแแ แแแแแจแแแก:
แแ แแ แแแงแแแ แซแแแแแ แคแ แแฎแแแแ แแ แแ แแแแแแแขแ unicorn แแแแก แแแกแแแแกแขแฃแ แแแแแ, แ แแ แงแแแแ แแแ แแแ แจแแกแ แฃแแแ
แจแแแแแ แแแแแแ แชแแขแ แแแขแ แแ แ, แแแแแ แ แแแแแแแแ แ แแแแฅแขแแ แแแ แแแแแแขแแ แแแแก แกแแคแฃแซแแแแแ แแ แแแแ แฎแแแก แแแแแขแ แ
แแกแ แ แแ, แแ แแแแฎแแ แฉแแแ แแแ แแแแ แคแฃแ แชแแแก แแแขแแ แ แแ แแแ แแแแฌแงแแก แแแฆแแแ
แแฅ แแ แแก แแแแแแแแ แ แแ แฉแแแแแ แแแกแขแแก แแแแแฅแแแงแแแแแก แแ แแก
แแแกแแแชแแ แแ แแแแแชแแแแ แแแแแก แแแกแขแ แฃแแแแขแแแ
แแแแแชแแแแ แแแแแก แแแกแขแ แฃแแแแขแแแแก แกแแแแแแแแแแแก แแ แแแแขแแ แแแฃแแ แกแแ
แแฅ แฉแแแ แแแแ แแแแแ แแแคแแ แแแชแแแก แแแกแแแชแแ แ แกแแกแแ แแแแแ แแ แแแกแแแชแแ แ แแฅแกแแแ แแแแแขแฃแแ แฎแแแกแแฌแงแแแแแก แจแแกแแฎแแ, แ แแแแแแแช แแแแ แขแแแแแก แแแแแชแแแแ แแแแแแก DBA, DevOps, Developers แแ แฃแแ แแแ แแแแแแแแแแแกแแแแก.
แแแแแ แแแแแแ แแแแแแขแแ แแแคแแ แแแชแแ แแฅแแแแ แกแแแฃแแแ แ db-แแแกแขแ แฃแแแแขแแแแก แแ แแฅแแแแ แกแแงแแแ แแแ แแแกแแแ แแฎแแ แแก db-แแแกแขแ แฃแแแแขแแแแก แจแแกแแฎแแ.
แจแแแแแ แกแ
IDE GUI แแแแแฏแแ แแแ/แแแแแแขแแแ CLI แแแกแขแ แฃแแแแขแแแ DB-แกแฅแแแแก แแแแแแแชแแ แแ แแแแฃแแแแแแชแแ แแแแแแแแ แแแ แแแแ แแชแแแก แแแกแขแ แฃแแแแขแแแ แแแแแก แแแแแ แแ แแแแก แฎแแแกแแฌแงแแแแ แจแแคแฃแแแ แกแแ แแแแ แแ แแแกแขแ แฃแแแแขแแแ แ แแแแแแแชแแ/แแแแแชแแแแ แแแแ แแชแแ Scripts แแแแแขแแ แแแแ / แกแขแแขแแกแขแแแ / แจแแกแ แฃแแแแ แขแแกแขแแ แแแ แแแแแแแกแขแ แแชแแ HA/Failover/Sharding แแฃแแแ แแแขแแแ แแแแคแแแฃแ แแชแแแก Tuning DevOps แกแฅแแแแก แแแแฃแจแแแ แแแแแ แแจแแแแ แแแกแขแ แแแฃแชแแ แฃแกแแคแ แแฎแแแแ แแแแแก แคแแ แแแขแแ แแแ
IDE
AnySQL แแแแกแขแ แ โ แแ แแแแแ แแ แแแแแคแฃแแฅแชแแฃแ แ แแแแแแแกแขแ แแขแแ แแก แแแกแขแ แฃแแแแขแ แแแแแชแแแแ แแแแแก แแแ แแแแก, แแแแขแ แแแแกแ แแ แแแแแแแแ แแแแกแแแแก.Aqua Data Studio โ Aqua Data Studio แแ แแก แแ แแแฃแฅแขแแฃแแแแแก แแ แแแ แแแฃแแ แฃแแ แฃแแแแแงแแคแ แแแแแชแแแแ แแแแแก แจแแแฅแแแแแแแแกแแแแก, DBA-แแแแกแแแแก แแ แแแแแแขแแแแกแแแแกแแแแก.แแแแแชแแแแ แแแแ.net โ แแแแแชแแแแ แแแแแก แแแ แแแแก แแ แแแแแฏแแ แแแ แแแกแขแ แฃแแแแขแ 20+ แแแแแชแแแแ แแแแแก แแฎแแ แแแญแแ แแ.แแแแแชแแแแ แแ แแแ โ Cross-Platform IDE แแแแแชแแแแ แแแแแแแกแแแแก แแ SQL JetBrains-แแก แแแแ .แแแแแแ แ โ แฃแคแแกแ แฃแแแแแ แกแแแฃแ แ แแแแแชแแแแ แแแแแก แแแแแฏแแ แ แแ SQL แแแแแแขแ.dbForge แกแขแฃแแแ MySQL-แกแแแแก - แฃแแแแแ แกแแแฃแ แ IDE MySQL แแ MariaDB แแแแแชแแแแ แแแแแก แแแแแแแแ แแแแก, แแแ แแแแกแ แแ แแแแแแแกแขแ แแ แแแแกแแแแก.dbForge แกแขแฃแแแ Oracle-แแกแแแแก โ แซแแแแ แ IDE Oracle-แแก แแแแแฏแแแแขแแก, แแแแแแแกแขแ แแชแแแกแ แแ แแแแแแแแ แแแแกแแแแก.dbForge แกแขแฃแแแ PostgreSQL-แแกแแแแก โ GUI แแแกแขแ แฃแแแแขแ แแแแแชแแแแ แแแแแแแกแ แแ แแแแแฅแขแแแแก แแแ แแแแกแ แแ แแแแแแแแ แแแแกแแแแก.dbForge แกแขแฃแแแ SQL แกแแ แแแ แแกแแแแก โ แซแแแแ แ แแแขแแแ แแ แแแฃแแ แแแแแแแแ แแแแก แแแ แแแ SQL Server-แแก แแแแแแแแ แแแแก, แแแ แแแแก, แแแแแแแกแขแ แแ แแแแก, แแแแแชแแแแ แแแแแแแแกแ แแ แแแฎแกแแแแแแกแแแแก.dbKoda โ แแแแแแแแ แแแ (JavaScript/Electron Framework), แฆแแ แแแแแก IDE MongoDB-แกแแแแก. แแแก แแฅแแก แคแฃแแฅแชแแแแ, แ แแแแแแแช แแฎแแ แก แฃแญแแ แก แแแแแแแแ แแแแก, แแแแแแแกแขแ แแ แแแแก แแ แจแแกแ แฃแแแแแก แแแ แแแฃแแแ แแแแก MongoDB แแแแแชแแแแ แแแแแแแ.IBExpert โ แงแแแแแกแแแแชแแแแ GUI แแแกแขแ แฃแแแแขแ Firebird-แแกแ แแ InterBase-แแกแแแแก.แฐแแแแ SQL โ แแกแฃแแฃแฅแ แแแแแแขแ MySQL, MSSQL แแ PostgreSQL แแแ แแแแกแแแแก, แแแฌแแ แแแ Delphi-แจแ.MySQL แกแแแฃแจแแ แแแแแแ โ MySQL Workbench แแ แแก แแ แแแแแ แแแแฃแแแฃแ แ แแแกแขแ แฃแแแแขแ แแแแแชแแแแ แแแแแก แแ แฅแแขแแฅแขแแ แแแแกแแแแก, แแแแแแแแแ แแแแกแแแแก แแ DBA-แแแแกแแแแก.แแแแแแแขแ โ แแแแแชแแแแ แแแแแก แแแแแแแแ แแแแก แแแกแขแ แฃแแแแขแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแ แแแ แแฃแแแ แแแฃแแแแจแแ แแแ MySQL, MariaDB, SQL Server, Oracle, PostgreSQL แแ SQLite แแแแแชแแแแ แแแแแแก แแ แแ แแแแแแแชแแแแแ.Oracle SQL แจแแแฅแแแแแ โ Oracle SQL Developer แแ แแก แฃแคแแกแ, แแแขแแแ แแ แแแฃแแ แแแแแแแแแ แฃแแ แแแ แแแ, แ แแแแแแช แแแแ แขแแแแแก Oracle แแแแแชแแแแ แแแแแก แจแแแฃแจแแแแแแกแ แแ แแแ แแแแก, แ แแแแ แช แขแ แแแแชแแฃแ, แแกแแแ Cloud-แจแ.pgAdmin โ แงแแแแแแ แแแแฃแแแ แฃแแ แแ แคแฃแแฅแชแแแแแ แแแแแแ แ แฆแแ แแแแแก แแแแแแแกแขแ แแชแแแกแ แแ แแแแแแแแ แแแแก แแแแขแคแแ แแ PostgreSQL-แแกแแแแก, แแกแแคแแแแจแ แงแแแแแแ แแแฌแแแแแ แฆแแ แแแแแก แแแแแชแแแแ แแแแ.pgAdmin3 - pgAdmin3-แแก แแ แซแแแแแแแแแ แแฎแแ แแแญแแ แ.PL/SQL แแแแแแแแแ แ โ IDE, แ แแแแแแช แกแแแชแแแแฃแ แแ แแ แแก แแแแแแแฃแแ Oracle-แแก แแแแแชแแแแ แแแแแแแกแแแแก แจแแแแฎแฃแแ แแ แแแ แแแแก แแ แแแฃแแแแแก แจแแแฃแจแแแแแแแ.PostgreSQL แแแแกแขแ แ โ แกแ แฃแแ แแ แซแแแแ แ แแแแแชแแแแ แแแแแก แแแแแฏแแแแขแ, แแแแแแแกแขแ แแขแแ แ แแ แแแแแแแแ แแแแก แแแกแขแ แฃแแแแขแ PostgreSQL-แแกแแแแก.แแแแแแจแ โ Toad แแ แแก แแแแแชแแแแ แแแแแก แแแแแแ แ แแแแแฌแงแแแขแ แแแแแแแแแ แแแแกแแแแก, แแแแแแแกแขแ แแขแแ แแแแกแแแแก แแ แแแแแชแแแแ แแแแแแขแแแแกแแแแกแแแแก. แแแ แแแ แแแแแชแแแแ แแแแแก แ แแฃแแ แชแแแแแแแแแ แแแแแชแแแแ แแแแแก แแแ แแแแก แแ แแ แแแกแขแ แฃแแแแขแแ.แแแแแแจแ Edge โ แแแแแ แขแแแแแฃแแ แแแแแชแแแแ แแแแแก แแแแแแแแ แแแแก แแแกแขแ แฃแแแแขแ MySQL แแ Postgres-แแกแแแแก.แแแ แ โ TOra แแ แแก แฆแแ แแแแแก SQL IDE Oracle, MySQL แแ PostgreSQL dbs.แกแขแฃแแแ แแแแแแขแแแ โ แจแแฅแแแแแ, แแแ แแแ, แแแแแแแฎแแ แแ แจแแแกแฌแแแแแ Valentina DB, MySQL, MariaDB, PostgreSQL แแ SQLite แแแแแชแแแแ แแแแแแ แฃแคแแกแแ.
GUI แแแแแฏแแ แแแ/แแแแแแขแแแ
แแแแแแแกแขแ แแขแแ แ โ แแแแแชแแแแ แแแแแก แแแ แแแ แแ แ PHP แคแแแแจแ.DbVisualizer โ แฃแแแแแ แกแแแฃแ แ แแแแแชแแแแ แแแแแก แแแกแขแ แฃแแแแขแ แแแแแแแแแ แแแแกแแแแก, DBA-แแแแกแแแแก แแ แแแแแแขแแแแกแแแแกแแแแก.HouseOps - Enterprise ClickHouse Ops UI, แ แแ แแแฃแจแแแ แแแแฎแแแแแแ, แแแแแแแ แแแ ClickHouse-แแก แฏแแแแ แแแแแแแก แแ แแแแคแแฅแ แแ แแแแ แ แกแฎแแ.JackDB โ แแแ แแแแแ แ SQL แฌแแแแแ แแฅแแแแก แงแแแแ แแแแแชแแแแ, แแ แแฅแแก แแแแจแแแแแแแ แกแแ แชแฎแแแ แแแก.OmniDB โ แแแ แแแกแขแ แฃแแแแขแ แแแแแชแแแแ แแแแแก แแแ แแแแกแแแแก.แแแแ แแ โ แแแ-แแ แแแคแฃแซแแแแฃแแ แแแแแชแแแแ แแแแแก แแ แแฃแแแ แ PostgreSQL-แแกแแแแก, แแแฌแแ แแแ Go-แจแ แแ แแฃแจแแแแก macOS, Linux แแ Windows แแแแฅแแแแแแ.phpLiteAdmin โ แแแแแ แแแคแฃแซแแแแฃแแ SQLite แแแแแชแแแแ แแแแแก แแแแแแแกแขแ แแชแแฃแแ แแแกแขแ แฃแแแแขแ แแแฌแแ แแแ PHP-แจแ SQLite3 แแ SQLite2-แแก แแฎแแ แแแญแแ แแ.phpMyAdmin โ แแแ แแแขแแ แคแแแกแ MySQL แแ MariaDB-แกแแแแก.แคแกแแแแแ โ PSequel แแแแแแแแแ แกแฃแคแแ แแ แแแ แขแแ แแแขแแ แคแแแกแก, แ แแ แกแฌแ แแคแแ แจแแแกแ แฃแแแ แกแแแ แแ PostgreSQL แแแแชแแแแแ.PopSQL โ แแแแแแแแ แแแ, แแ แแแแแแแ SQL แ แแแแฅแขแแ แ แแฅแแแแ แแฃแแแแกแแแแก.แแแกแขแแแ - แแแแแแแแ แแแ PostgreSQL แแแแแแขแ Mac-แแกแแแแก.Robo 3T โ Robo 3T (แงแแคแแแ Robomongo) แแ แแก แญแฃแ แแแแ แแ แแแแขแแ แแแฃแแ cross-platform MongoDB แแแ แแแแก แแแกแขแ แฃแแแแขแ.แแแแ แซแแแแแ แแ แ โ Sequel Pro แแ แแก แกแฌแ แแคแ, แแแแแแแ แแแแแกแแงแแแแแแแ Mac แแแแแชแแแแ แแแแแก แแแ แแแแก แแแแแแแชแแ MySQL แแ MariaDB แแแแแชแแแแ แแแแแแแแ แแฃแจแแแแแกแแแแก.SQL Operations Studio โ แแแแแชแแแแ แแแ แแแแก แแแกแขแ แฃแแแแขแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แแแฃแจแแแ SQL Server, Azure SQL DB แแ SQL DW Windows-แแแ, macOS-แแแ แแ Linux-แแแ.SQLite แแฅแกแแแ แขแ - แแ แแคแแแฃแแ แแแขแแ แคแแแกแ แแฎแแ แก แฃแญแแ แก SQLite-แแก แงแแแแ แคแฃแแฅแชแแแก.sqlpad โ แแแแแ แแแคแฃแซแแแแฃแแ SQL แ แแแแฅแขแแ แ แแฃแจแแแแก แแฅแแแแก แแแ แแ แฆแ แฃแแแแจแ.SQLPro โ แแแ แขแแแ, แซแแแแ แ Postgres แแแแแฏแแ แ macOS-แแกแแแแก.SquirreL โ Java-แจแ แแแฌแแ แแแ แแ แแคแแแฃแแ SQL แแแแแแขแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแแชแแแ แแฎแแแแ JDBC แจแแกแแแแแแกแ แแแแแชแแแแ แแแแแก แกแขแ แฃแฅแขแฃแ แ, แแแแแแแแแแ แแ แแแแแชแแแแแ แชแฎแ แแแแแจแ, แแแกแชแแ SQL แแ แซแแแแแแแ แแ แ.แจ.SQLTools - แแแแแชแแแแ แแแแแก แแแ แแแ VSCode-แกแแแแก.SQLyog โ แงแแแแแแ แกแ แฃแแงแแคแแแ แแ แแแ แขแแแ แแแแแกแแงแแแแแแแ MySQL GUI.แขแแแแฅแกแ - SQL แ แแแแฅแขแแ แ แแ แฆแแ แแแแแก แแแ แขแแแ แแแแแแก แแแขแแแแฅแขแ Clickhouse-แกแแแแก.แแแแแแแก แแแฃแกแ - แแแแแแแแ แแแ, แแจแแแแแฃแ แ แแ แแแแแแ แฃแแ GUI แแแกแขแ แฃแแแแขแ แ แแแแขแแฃแ แ แแแแแชแแแแ แแแแแแแกแแแแก: MySQL, PostgreSQL, SQLite แแ แกแฎแแ.TeamPostgreSQL - PostgreSQL แแแ แแแแแแแกแขแ แแชแแแก GUI - แแแแแแงแแแแ แแฅแแแแ PostgreSQL แแแแแชแแแแ แแแแแแ แแแแแกแแแแ แ แแแแแแแแแ, แแแแแแ แ, แแแแแกแแแฃแ แ AJAX แแแ แแแขแแ แคแแแกแแ.
CLI แแแกแขแ แฃแแแแขแแแ
ipython-sql โ แแแฃแแแแจแแ แแแ แแแแแชแแแแ แแแแแก SQL แแ แซแแแแแแแแก แแแกแแชแแแแ IPython-แจแ แแ IPython Notebook-แจแ.แแ แแแแก - Cli Redis-แแกแแแแก แแแขแแแแขแฃแ แ แแแกแ แฃแแแแแ แแ แกแแแขแแฅแกแแก แฎแแแแแกแแแ.pgcenter - แงแแแแแแ แแกแแแแกแ แแแแแแแกแขแ แแขแแ แแก แแแกแขแ แฃแแแแขแ PostgreSQL-แแกแแแแก.pg_แแฅแขแแแแแ โ แงแแแแแแ แแกแแแแกแ แแแแแแแชแแ PostgreSQL แกแแ แแแ แแก แแฅแขแแแแแแก แแแแแขแแ แแแแแกแแแแก.pg_top - "แแแแ" PostgreSQL-แแกแแแแก.pspg - แแแกแขแแ แแก แแแแฏแแ แsqlcl โ Oracle SQL Developer Command Line (SQLcl) แแ แแก แฃแคแแกแ แแ แซแแแแแแก แฎแแแแก แแแขแแ แคแแแกแ Oracle แแแแแชแแแแ แแแแแกแแแแก.usql - แฃแแแแแ แกแแแฃแ แ แแ แซแแแแแแก แฎแแแแก แแแขแแ แคแแแกแ PostgreSQL, MySQL, Oracle Database, SQLite3, Microsoft SQL Server,แแ แแ แแแแแ แกแฎแแ แแแแแชแแแแ แแแแ แแแ แจแแ แแก NoSQL แแ แแ แแ แแแแชแแฃแ แ แแแแแชแแแแ แแแแแแ!
dbcli
แแแแแแ โ AthenaCLI แแ แแก CLI แแแกแขแ แฃแแแแขแ AWS Athena แกแแ แแแกแแกแแแแก, แ แแแแแกแแช แจแแฃแซแแแ แแแขแแแแขแฃแ แ แแแกแ แฃแแแแ แแ แกแแแขแแฅแกแแก แฎแแแแแกแแ.แแแขแแแแ - CLI SQLite แแแแแชแแแแ แแแแแแแกแแแแก แแแขแแแแขแฃแ แ แจแแแกแแแแ แแ แกแแแขแแฅแกแแก แฎแแแแแกแแแ.mssql-cli โ แแ แซแแแแแแก แฎแแแแก แแแแแแขแ SQL Server-แแกแแแแก แแแขแแแแขแฃแ แ แจแแแกแแแแ แแ แกแแแขแแฅแกแแก แฎแแแแแกแแแ.แแแแแ โ แขแแ แแแแแแฃแ แ แแแแแแขแ MySQL-แกแแแแก แแแขแแแแขแฃแ แ แแแกแ แฃแแแแแ แแ แกแแแขแแฅแกแแก แฎแแแแแกแแแ.pgcli - Postgres CLI แแแขแแแแขแฃแ แ แจแแแกแแแแ แแ แกแแแขแแฅแกแแก แฎแแแแแกแแแ.vcli โ Vertica CLI แแแขแแแแขแฃแ แ แจแแแกแแแแ แแ แกแแแขแแฅแกแแก แฎแแแแแกแแแ.
DB-แกแฅแแแแก แแแแแแแชแแ แแ แแแแฃแแแแแแชแแ
dbdiagram.io โ แกแฌแ แแคแ แแ แแแ แขแแแ แฎแแแกแแฌแงแ, แ แแแแแแช แแแแแฎแแแ แแแแ แแแฎแแแแ แแฅแแแแ แแแแแชแแแแ แแแแแก แฃแ แแแแ แแแแแก แแแแแ แแแแแ แแ แกแฌแ แแคแแ แแแแซแ แแแ แแแ แขแแแ DSL แแแแก แแแแแงแแแแแแ.แแ แแแฅแแแแ - แแ แแแฃแแแแแก แฃแ แแแแ แแแแแก แแแแแ แแแแแแก แแแแแ แแ แแแแก แแแกแขแ แฃแแแแขแ.SchemaCrawler โ แฃแคแแกแ แแแแแชแแแแ แแแแแก แกแฅแแแแก แแฆแแแฉแแแแกแ แแ แแแแแแแก แแแกแขแ แฃแแแแขแ.แกแฅแแแ Spy โ แแฅแแแแ แแแแแชแแแแ แแแแแก แแแแแ แแ แแแ HTML แแแแฃแแแแขแแชแแแจแ, แแแ แจแแ แแก แแ แแแฃแแแแแแ แฃแ แแแแ แแแแแก แแแแแ แแแแแ.แกแขแแแแแก โ CI-Friendly แแแกแขแ แฃแแแแขแ แแแแแชแแแแ แแแแแก แแแแฃแแแแขแแชแแแกแแแแก, แแแฌแแ แแแ Go-แจแ.
แแแแแแแแ แแแ
Navicat แแแแแชแแแแ แแแแแแแ แ โ แแแแแชแแแแ แแแแแก แแแแแแแแก แแซแแแแ แ แแ แแแแแแแแฃแ แ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแแแแฎแแแ แแแแ แจแแฅแแแแ แแแฆแแแ แฎแแ แแกแฎแแก แแแแชแแแขแฃแแแฃแ แ, แแแแแแฃแ แ แแ แคแแแแแฃแ แ แแแแแชแแแแแแก แแแแแแแแ.Oracle SQL Developer Data Modeler โ Oracle SQL Developer Data Modeler แแ แแก แฃแคแแกแ แแ แแคแแแฃแแ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแ แแแก แแ แแแฃแฅแขแแฃแแแแแก แแ แแแแ แขแแแแแก แแแแแชแแแแ แแแแแแแ แแแแก แแแแชแแแแแก.pgmodeler โ แแแแแชแแแแ แแแแแแแ แแแแก แแแกแขแ แฃแแแแขแ, แ แแแแแแช แจแแฅแแแแแแ PostgreSQL-แแกแแแแก.
แแแแ แแชแแแก แแแกแขแ แฃแแแแขแแแ
2 แแแกแ โ แแแแแชแแแแ แแแแแก แแแแคแแแฃแ แแชแแ-แ แแแแ แช แแแแแก แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแงแแแแแก แแแแแแแขแแแขแฃแ แ DDL แกแแ แแแขแแแแก แแแแชแแคแชแแแก.แกแแคแ แแแ แแแ - แแแแแชแแแแ แแแแแก แแแแ แแชแแแก แแแกแขแ แฃแแแแขแ.gh-ost โ แแแแแแ แกแฅแแแแก แแแแ แแชแแ MySQL-แกแแแแก.แแแแแแแแแ โ แแแแแชแแแแ แแแแแแแ แแแแแฃแแแแแแแแ แแแแแแแแแแ แแแแแชแแแแ แแแแแก แกแฅแแแแก แชแแแแแแแแแแก แแแแแงแฃแ แแก แแแแแแก, แแแ แแแแกแ แแ แแแแแงแแแแแแกแแแแก.แจแแแแแ - แแแแฌแแแก แแแแกแฎแแแแแแ, แแแแ แแ PostgreSQL แกแฅแแแแแแกแแแแก.node-pg-migrate โ Node.js แแแแแชแแแแ แแแแแก แแแแ แแชแแแก แแแแแฏแแแแขแ แจแแฅแแแแแแ แแฅแกแแแฃแแแฃแ แแ แแแกแขแแ แแกแแกแแแแก. (แแแแ แแ แแกแแแ แจแแแซแแแแ แแแแแงแแแแแฃแ แแฅแแแก แกแฎแแ DB-แแแแกแแแแก, แ แแแแแแแช แจแแแกแแแแแแแ SQL แกแขแแแแแ แขแก - แแแ. CockroachDB.)แแแ แกแแแกแ โ แฃแแ แฃแแแแแงแแคแก แแแแฃแแแแฃแ แแ แแแ แแแแแก PostgreSQL แแแแแชแแแแ แแแแแก แกแฅแแแแก YAML-แแก แกแแฎแแ แแฆแฌแแ แแกแแแแก.SchemaHero โ Kubernetes แแแแ แแขแแ แ แแแแแแ แแชแแฃแแ แแแแแชแแแแ แแแแแก แกแฅแแแแแแก แแแ แแแแกแแแแก (gitops แแแแแชแแแแ แแแแแก แกแฅแแแแแแกแแแแก).แกแแแฉแ โ แแแแแชแแแแ แแแแแก แแแแแแ แฃแแ แชแแแแแแแแแแก แแแแแฏแแแแขแ แฉแแ แฉแแก แแแ แแจแ แแแแแแแแ แแแแกแแแแก แแ แกแแแแแแ แแแแแแแแแแกแแแแก.yuniql โ แแแแแ แแ แแ แกแฅแแแแก แแแ แกแแแแแก แแ แแแแ แแชแแแก แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแฎแแแฎแแ แจแแแฅแแแ แแจแแแแแฃแ แ .NET Core 3.0+-แแ แแ แแแแแแ แฃแแแแแกแ.
แแแแแก แแแแแ แแ แแแแก แฎแแแกแแฌแงแแแแ
ddl-แแแแแ แแขแแ แ โ แแกแแแแแก SQL DDL (แแแแแชแแแแ แแแแแแ แขแแแแก แแแ) แชแฎแ แแแแก แแแแแชแแแแแแแแ.scheme2ddl โ Oracle-แแก แกแฅแแแแก แแฅแกแแแ แขแแกแแแแก แแ แซแแแแแแก แฎแแแ ddl init แกแแ แแแขแแแแก แแแแ แแแแกแแแแก แแ แแกแแกแฃแ แแแแ แแแคแแ แแแชแแแก แแแคแแแขแแ แแก แจแแกแแซแแแแแแแแ, DDL-แแก แแแแแงแแคแ แกแฎแแแแแกแฎแแ แคแแแแแแจแ, แแแแแแ แคแแ แแแขแแก แแแแแแแแแแ.
แจแแคแฃแแแ
แแชแแแแแก แฅแแ แฎแแแ โ แฆแแ แแแแแก REST API backend แแแแแแฃแ แ, แแแ แแ IoT แแแแแแแชแแแแแกแแแแก.Hasura GraphQL Engine - แแงแแกแแแ แ แกแฌแ แแคแ, แแงแแกแแแ แ แ แแแแฃแ แแ แแจแ GraphQL API-แแแ Postgres-แแ แฌแแแแแแก แฌแแ แแแแแ แชแแแแแแแ แแแแขแ แแแแ, แแกแแแ แแแฅแขแแฃแ แแแก แแแ-แฐแฃแแแแก แแแแแชแแแแ แแแแแก แแแแแแแแแแ.jl-sql - SQL JSON แแ CSV แแแแแแแแแกแแแแก.mysql_fdw - PostgreSQL แฃแชแฎแแฃแ แ แแแแแชแแแแแแก แจแแคแฃแแแ MySQL-แกแแแแก.Oracle REST แแแแแชแแแแ แกแแ แแแกแแแ โ แกแแจแฃแแแ แแแแแก Java แแแแแแแชแแ, ORDS แแกแแฎแแแก HTTP(S) แแแแแแก (GET, POST, PUT, DELETE แแ แ.แจ.) แแแแแชแแแแ แแแแแก แขแ แแแแแฅแชแแแแจแ แแ แแแ แฃแแแแก JSON-แแก แแแแแงแแแแแแ แคแแ แแแขแแ แแแฃแ แแแแแกแแแแ แจแแแแแก.Prisma โ Prisma แแฅแชแแแก แแฅแแแแก แแแแแชแแแแ แแแแแก แ แแแแฃแ แแ แแจแ GraphQL API-แแ.postgREST - REST API แแแแแกแแแแ แ Postgres แแแแแชแแแแ แแแแแกแแแแก.แแแ แกแข โ แแ แแก แแแ RESTful API-แแก แแแแกแแฎแฃแ แแแแกแแแแก Go-แจแ แแแฌแแ แแแ แแแแแกแแแแ แ แแแแแชแแแแ แแแแแแแ.restSQL โ SQL แแแแแ แแขแแ แ Java แแ HTTP API-แแแแ, แแงแแแแแก แแแ แขแแ RESTful HTTP API-แก XML แแ JSON แกแแ แแฃแแแแแชแแแ.แฃแแ แแงแแคแแแ - แแแ แขแแแแ แแแแแแแแแแ แแฅแแแแ SQL แแแแแชแแแแ แแแแ REST API-แจแ.แฅแแแจแแก แแแชแ 2 โ แแแขแแแแขแฃแ แแ แแแแแ แแ แแแ RESTful API แกแแ แแแกแ แแฅแแแแ แแแแแแแแ แแแแแก แแแแแชแแแแ แแแแแกแแแแก.sql-boot โ แแแคแแ แแแแแฃแแ REST แแ UI แจแแคแฃแแแ แแฅแแแแ SQL แแแแฎแแแแแแแกแแแแก.
แกแแ แแแแ แแ แแแกแขแ แฃแแแแขแแแ
pgbackrest - แกแแแแ PostgreSQL แกแแ แแแแ แแ แแ แแฆแแแแแ.แแแ แแแแ - แกแแ แแแแ แแ แแ แแฆแแแแแแก แแแแแฏแแ แ PostgreSQL-แกแแแแก.
แ แแแแแแแชแแ/แแแแแชแแแแ แแแแ แแชแแ
แแแแแชแแแแ แแแแ แแแ โ แแแกแขแ แฃแแแแขแ แแแแแชแแแแแแก แจแแกแแกแฌแแแแแ แแ แแแแแฅแแแงแแแแแกแแแแก.dtle โ แแแแแฌแแแแแฃแแ แแแแแชแแแแ แแแแแชแแแแก แกแแ แแแกแ MySQL-แกแแแแก.pgsync - แแแแแชแแแแ แแแแแแก แจแแ แแก Postgres-แแก แแแแแชแแแแแแก แกแแแฅแ แแแแแแชแแ.pg_แฅแแแแแแแแ โ Python 3-แจแ แแแฌแแ แแแ MySQL-แแแ PostgreSQL-แแก แ แแแแแแ แกแแกแขแแแแจแ. แกแแกแขแแแ แแงแแแแแก แแแแแแแแแแแก mysql-แ แแแแแแแชแแแก MySQL-แแแ แแฌแแ แแแแก แกแฃแ แแแแแแก แแแแแกแแขแแแแ, แ แแแแแแแช แแแแฎแแแ PostgreSQL-แจแ JSONB-แแก แกแแฎแแ.PGDeltaStream โ Golang-แแก แแแแกแแ แแแ แ Postgres-แแก แกแขแ แแแแแแแกแแแแก แแชแแแแแ แแแแแแฃแ แแ แแฎแแ แแแแกแแแแขแแแแ, Postgres-แแก แแแแแแฃแ แ แแแแแแแ แแแแก แคแฃแแฅแชแแแก แแแแแงแแแแแแ.แ แแแแแ - แงแแแแแแ แแแแฃแแแ แฃแแ แ แแแแแแแชแแแก แแแแแฏแแ แ PostgreSQL-แแกแแแแก.
Scripts
pgx_scripts โ แแแแแชแแแแ แแแแแก แแแแแแแแกแ แแ แแแแแแแกแขแ แแ แแแแกแแแแก แกแแกแแ แแแแแ แแแขแแ แ แกแแ แแแขแแแแก แแแแแฅแชแแ, แจแแฅแแแแแ แฉแแแแ แแฃแแแแก แแแแ PostgreSQL Experts-แจแ.pgsql-bloat-estimation - แแแแฎแแแแแแ PostgreSQL-แแกแแแแก แแแแแฅแกแแแจแ แแ แชแฎแ แแแแแจแ แกแขแแขแแกแขแแแฃแ แ แจแแแแ แแแแแแก แแแกแแแแแแ.pgWikiDont โ SQL แขแแกแขแ, แ แแแแแแช แแแแฌแแแแก, แจแแแกแแแแแแแ แแฃ แแ แ แแฅแแแแ แแแแแชแแแแ แแแแ แฌแแกแแแกhttps://wiki.postgresql.org/wiki/Donโt_Do_This .pg-utils - แกแแกแแ แแแแแ PostgreSQL แฃแขแแแแขแแแ.Postgres แแแขแงแฃแแแแก แคแฃแ แชแแแ - แกแแกแแ แแแแแ SQL-แกแแ แแแขแแแ แแ แแ แซแแแแแแแ .postgres_dba - แแแแแขแแแแแฃแแ แกแแกแแ แแแแแ แแแกแขแ แฃแแแแขแแแแก แแแแ แแแ Postgres DBA-แกแแแแก แแ แงแแแแ แแแแแแ แแกแแแแก.postgres_queries_and_commands.sql - แกแแกแแ แแแแแ PostgreSQL แแแแฎแแแแแแ แแ แแ แซแแแแแแแ.TPT โ แแก sqlplus แกแแ แแแขแแแ แแแแแฃแแแแแแแ Oracle แแแแแชแแแแ แแแแแก แแฃแจแแแแแก แแแขแแแแแแชแแแกแ แแ แแ แแแแแแแแแก แแแแแแ แแแแกแแแแก.
แแแแแขแแ แแแแ / แกแขแแขแแกแขแแแ / แจแแกแ แฃแแแแ
ASH แแแงแฃแ แแแแแ โ แแแแแแแแแ แแฅแขแแฃแ แ แกแแกแแแแแก แแกแขแแ แแแก แแแแแชแแแแแแก แแ แแคแแแฃแ แฎแแแแแก Oracle-แกแ แแ PostgreSQL DB-แจแ.แแแแแแแ โ แแแแแขแฃแ แ แแ แแแแแแแแฃแ แ MySQL แแแแแขแแ แแแแแก แแแกแขแ แฃแแแแขแ.mssql-แแแแแขแแ แแแแ โ แแแแแแแ แแแ แแฅแแแแก SQL แกแแ แแแ แก Linuxโแแก แแฃแจแแแแแแ, แจแแแ แแแแแฃแแ, InfluxDB แแ Grafanaโแก แแแแแงแแแแแแ.แแแแแแแขแแก แแแแแขแแ แ โ แฃแกแแคแ แแฎแ, แแแ แขแแแ แแ แแแแแขแแก แแแ แแจแ แแแกแขแแแชแแฃแ แ แกแแ แแแ แแก แแแแแขแแ แแแแแก แแแกแขแ แฃแแแแขแ, แ แแแแแแช แจแแคแฃแแฃแแแ แซแแแแ แ แคแฃแแฅแชแแแแแ, แ แแแ แแฅแแแแ แแแแแขแแ แแแแ แแแฅแกแแแแแฃแ แแ แแคแแฅแขแฃแ แ แแงแแก.แแแ แแแแแก แแแแแขแแ แแแแ แแ แแแ แแแ โ แฆแแ แแแแแก แแแแขแคแแ แแ MySQL แแ MongoDB แแฃแจแแแแแก แแแ แแแแกแ แแ แแแแแขแแ แแแแแกแแแแก.pganalyze แแแแแฅแชแแแแแ แ โ แกแขแแขแแกแขแแแแก แจแแแแ แแแแแแแก แแแแแแแ PostgreSQL แแแขแ แแแแกแ แแ แแฃแ แแแแแก แแแแแชแแแแแแก แจแแกแแแ แแแแแแแ.แแแกแขแแ แแก-แจแแแแฌแแแแ โ แแฎแแแ แแแแแแก แแแแแแแกแขแแแฃแ แ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแแแฎแแแ แแแแแแก แกแแจแฃแแแแแแก แแซแแแแก แแแแแแแแ แแแกแขแแ แแกแแก แแแแแชแแแแ แแแแแแแก แกแแฏแแแกแแฆแแก แฆแ แแ แแแแแแแ.แแแกแขแแ แแกแ_แแฅแกแแแ แขแแแ แ โ แแ แแแแแแก แแฅแกแแแ แขแแแ แ PostgreSQL แกแแ แแแ แแก แแแขแ แแแแแแกแแแแก.pgDash - แแแแแแแ แแ แแแแแงแฃแ แ แแแแแแแ แแฅแแแแ PostgreSQL แแแแแชแแแแ แแแแแแแก แงแแแแ แแกแแแฅแขแก.PgHero - แแฃแจแแแแแก แแแคแ Postgres-แแกแแแแก - แฏแแแแ แแแแแแแก แจแแแแฌแแแแ, แจแแแแแแแแแแแฃแแ แแแแแฅแกแแแ แแ แกแฎแแ.pgmetrics โ แจแแแแ แแแแ แแ แแฉแแแแแ แแแคแแ แแแชแแ แแ แกแขแแขแแกแขแแแ แแแจแแแแฃแแ PostgreSQL แกแแ แแแ แแแแ.pgแแแแแแ - Postgres-แแก แแแแฎแแแ แแแแแก แแแขแแ แคแแแกแ แแแแแแ แขแแแก แแแแแแแก, แแแฃแก แ แฉแแแแแก แจแแกแ แฃแแแแแก แแแกแแฃแแฏแแแแกแแแแแ.pgstats โ แแแ แแแแแก PostgreSQL แกแขแแขแแกแขแแแแก แแ แแ แแแแฎแแแก แแแ CSV แคแแแแแแจแ แแ แแแญแแแแก แแแ stdout-แแ.pgwatch2 - แแแฅแแแแ แแแแแแแแ แแแแแแแแก PostgreSQL แแแขแ แแแแก แแแแแขแแ แแแแแก/แแแคแแแแก แแแแแฌแงแแแขแ.Telegraf PostgreSQL แแแแฃแแ โ แแแแแแแแแ แแแขแ แแแแก แแฅแแแแ แแแกแขแแ แแกแแก แแแแแชแแแแ แแแแแกแแแแก.
แแแแฅแกแ
แแแแแแกแฃ - แแแแแขแแ แแแแแก แแแแแขแ PostgreSQL-แกแแแแก.แแ แแแแฅแกแ โ Orabbix แแ แแก แแแแฃแแ, แ แแแแแแช แจแแฅแแแแแแ Zabbix Enterprise Monitor-แแแ แแฃแจแแแแแกแแแแก, แ แแแ แฃแแ แฃแแแแแงแแก แแ แแแแแกแแคแแฎแฃแ แแแแ แแแแแขแแ แแแแ, แจแแกแ แฃแแแแแก แแ แฎแแแแแกแแฌแแแแแแแแก แแแฎแกแแแแแ แแ แแแแแแแ Oracle แแแแแชแแแแ แแแแแแแกแแแแก, แกแแ แแแ แแก แแฃแจแแแแแก แแแขแ แแแแกแแแ แแ แแแ.pg_monz โ แแก แแ แแก Zabbix แแแแแขแแ แแแแแก แจแแแแแแ PostgreSQL แแแแแชแแแแ แแแแแกแแแแก.แแแแ แ - แแแแแแแก แกแแ แแแขแ Oracle แแแแแชแแแแ แแแแแแแก แแแแแขแแ แแแแแกแแแแก.ZabbixDBA - ZabbixDBA แแ แแก แกแฌแ แแคแ, แแแฅแแแแ แแ แแฃแแแแแแ แแแแแแแแ แแแแแ แแแแฃแแ แแฅแแแแ RDBMS แแแแแขแแ แแแแแกแแแแก.
แขแแกแขแแ แแแ
DbFit - แแแแแชแแแแ แแแแแก แขแแกแขแแ แแแแก แฉแแ แฉแ, แ แแแแแแช แแฎแแ แก แฃแญแแ แก แแฅแแแแ แแแแแชแแแแ แแแแแก แแแแแก แแแ แขแแ แขแแกแขแแ แแ แแแแขแแ แแแฃแ แแแแแแแแ แแแแก.RegreSQL โ แแฅแแแแ SQL แแแแฎแแแแแแแก แ แแแ แแกแแแก แขแแกแขแแ แแแ.
แแแแแชแแแแ แแแแแ แแขแแ แ
Databene Benerator โ แแก แแ แแก แฉแแ แฉแ แแฅแแแแ แกแแกแขแแแแกแแแแก แ แแแแแกแขแฃแ แ แแ แแแฅแแแแ แแแฆแแแ แแแชแฃแแแแแก แขแแกแขแแก แแแแแชแแแแแแก แแแแแ แแ แแแแกแแแแก (Datalite แแแขแ แจแแแแแแแก แแแแแแแ แแชแแแแแแก แแแแแแ).dbForge แแแแแชแแแแ แแแแแ แแขแแ แ MySQL-แกแแแแก โ แซแแแแ แ GUI แแแกแขแ แฃแแแแขแ แ แแแแแกแขแฃแ แ แขแแกแขแแก แแแแแชแแแแแแก แฃแแแ แแแแแ แ แแแชแฃแแแแแก แจแแกแแฅแแแแแแ.dbForge แแแแแชแแแแ แแแแแ แแขแแ แ Oracle-แแกแแแแก - แแชแแ แ, แแแแ แแ แซแแแแ แ GUI แแแกแขแ แฃแแแแขแ Oracle-แแก แกแฅแแแแแแก แแแกแแกแแฎแแแแแแ แ แแแแแกแขแฃแ แ แขแแกแขแแก แแแแแชแแแแแแ.dbForge แแแแแชแแแแ แแแแแ แแขแแ แ SQL แกแแ แแแ แแกแแแแก - แซแแแแ แ GUI แแแกแขแ แฃแแแแขแ แแแแแชแแแแ แแแแแแแกแแแแก แแแแจแแแแแแแแแ แขแแกแขแแก แแแแแชแแแแแแก แกแฌแ แแคแ แฌแแ แแแฅแแแแกแแแแก.
แแแแแแแกแขแ แแชแแ
แแแแแแแแ แ - แกแฌแ แแคแ PostgreSQL แแฃแ แแแแแก แแแแแแแแขแแ แ.pgbedrock โ แแแ แแแ Postgres แแแแกแขแแ แแก แ แแแแแ, แ แแแฃแ แ แฌแแแ แแแแแ, แกแฅแแแแก แแคแแแแแแแแ แแ แแ แแแแแแแแแแ.pgslice - Postgres แแแงแแคแ แแกแแแแแ แแแ แขแแแแ, แ แแแแ แช แขแแ แขแ.
HA/Failover/Sharding
แชแแขแฃแกแแก โ Postgres แแแคแแ แแแแแ, แ แแแแแแช แแแแฌแแแแแก แแฅแแแแก แแแแแชแแแแแกแ แแ แแฅแแแแก แแแแฎแแแแแแก แแ แแแแ แแแแแซแจแ.แแแขแ แแแ โ แจแแแแแแ PostgreSQL แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแกแแแแก ZooKeeper-แแแ, etcd-แแแ แแ แแแแกแฃแแแแ.Percona XtraDB แแแแกแขแแ แ โ แแแฆแแแ แแแกแจแขแแแฃแ แแแแก แแแแแฌแงแแแขแ MySQL แแแแกแขแแ แแแแแกแ แแ แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแกแแแแก.แกแขแแแแแ - แฆแ แฃแแแแแแแ PostgreSQL แแแแแฏแแ แ PostgreSQL แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแกแแแแก.pg_auto_failover โ Postgres-แแก แแแคแแ แแแแแ แแ แกแแ แแแกแ แแแขแแแแขแฃแ แ แจแแชแแแแแกแ แแ แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแกแแแแก.pglookout - PostgreSQL แ แแแแแแแชแแแก แแแแแขแแ แแแแ แแ แฌแแ แฃแแแขแแแแแแแก แแแแแแ.PostgreSQL แแแขแแแแขแฃแ แ แฌแแ แฃแแแขแแแแแแ - แแแฆแแแ แฎแแแแแกแแฌแแแแแแแ Postgres-แแกแแแแก, แแแคแฃแซแแแแฃแแ แแแแฃแกแขแ แแแก แชแแแแแแแ Pacemaker แแ Corosync.postgresql_cluster โ PostgreSQL แแแฆแแแ แฎแแแแแกแแฌแแแแแแแแก แแแแกแขแแ แ (แแแคแฃแซแแแแฃแแแ "Patroni" แแ "DCS(etcd)"). แแแแแแแแแแก แแแขแแแแขแแแแชแแ Ansible-แแ.แแแขแแกแ โ แแแแแชแแแแ แแแแแก แแแแกแขแแ แฃแแ แกแแกแขแแแ MySQL-แแก แฐแแ แแแแแขแแแฃแ แ แกแแแแแ แแแแก แแแแแแ แแแแแแแแแแแฃแแ แจแแ แฌแงแแแก แแแแ.
แแฃแแแ แแแขแแแ
KubeDB โ แฌแแ แแแแแแก แแแแแก แแแแแชแแแแ แแแแแก แแแจแแแแ Kubernetes-แแ แแแ แขแแแ.แแแกแขแแ แแกแแก แแแแ แแขแแ แ - Postgres แแแแ แแขแแ แ แกแแจแฃแแแแแแก แแซแแแแก แแแฆแแ แฎแแแแแกแแฌแแแแ PostgreSQL แแแแกแขแแ แแแก Kubernetes-แแ (K8s) แแแขแ แแแแแแก แแแแ .แกแแแแ - HA PostgreSQL แแแแกแขแแ แแแ Docker-แแ.StackGres - Enterprise-grade, Full Stack PostgreSQL Kubernetes-แแ.
แแแแคแแแฃแ แแชแแแก Tuning
MySQLTuner-perl โ Perl-แจแ แแแฌแแ แแแ แกแแ แแแขแ, แ แแแแแแช แกแแจแฃแแแแแแก แแแซแแแแ แกแฌแ แแคแแ แแแแแฎแแแแ MySQL แแแกแขแแแแชแแแก แแ แแแแแแแแ แแแ แแฅแขแแ แแแ, แ แแแ แแแแแ แแแ แจแแกแ แฃแแแแ แแ แกแขแแแแแฃแ แแแ.PGConfigurator โ แฃแคแแกแ แแแแแแ แแแกแขแ แฃแแแแขแ แแแขแแแแแแ แแแฃแแแก แจแแกแแฅแแแแแแpostgresql.conf
.pgtune - PostgreSQL แแแแคแแแฃแ แแชแแแก แแกแขแแขแ.postgresqltuner.pl - แแแ แขแแแ แกแแ แแแขแ แแฅแแแแ PostgreSQL แแแแแชแแแแ แแแแแก แแแแคแแแฃแ แแชแแแก แแแกแแแแแแแแแแแแ แแ แ แฉแแแแแแก แแแกแแ แแแฃแแแ แแแแแ.
DevOps
DBmaestro โ DBmaestro แแฉแฅแแ แแแก แแแแแจแแแแแก แชแแแแแแก แแ แแฎแแ แก แฃแญแแ แก แกแแกแฌแ แแคแแก แแแแ IT แแแแกแแกแขแแแแจแ.Toad DevOps Toolkit โ Toad DevOps Toolkit แแฎแแ แชแแแแแแก แแแแแชแแแแ แแแแแก แแแแแแแแ แแแแก แซแแ แแแแ แคแฃแแฅแชแแแแก แแฅแแแแ DevOps แกแแแฃแจแแ แแ แแชแแกแแก แคแแ แแแแแจแ โ แฎแแ แแกแฎแแก, แแฃแจแแแแแก แแ แกแแแแแแแแแแก แแแแแ แแแแขแแ แแแแก แแแ แแจแ.
แกแฅแแแแก แแแแฃแจแแแ
Oracle แแแแแชแแแแ แแแแแก แแแแฃแจแแก แกแฅแแแแแ - Oracle แแแแแชแแแแ แแแแแก แแแแฃแจแแก แกแฅแแแแแ.
แแแแแ แแจแแแแ
Poli โ แแแแแแแ แแแแแกแแงแแแแแแแ SQL แแแแแ แแจแแแแแก แแแแแแแชแแ, แ แแแแแแช แจแแฅแแแแแแ SQL แแแงแแแ แฃแแแแแกแแแแก.
แแแกแขแ แแแฃแชแแ
DBdeployer โ แแแกแขแ แฃแแแแขแ, แ แแแแแแช แแแ แชแแแแแก MySQL แแแแแชแแแแ แแแแแก แกแแ แแแ แแแก แแแ แขแแแแ.dbatools โ PowerShell แแแแฃแแ, แ แแแแแแช แจแแแซแแแแ แแแแแฉแแแแแ, แ แแแแ แช แแ แซแแแแแแก แฎแแแ SQL Server Management Studio.Postgres.app โ แกแ แฃแแ แแแแแ แฉแแฃแแ PostgreSQL แแแกแขแแแแชแแ แจแแคแฃแแฃแแแ แ แแแแ แช แกแขแแแแแ แขแฃแแ Mac แแแแแแแชแแ.BigSQL - Postgres-แแก แแแแแแแแแ แแแแกแแแแก แแแกแแฎแแ แฎแแแแแ แแแแแฌแแแแแ.แกแแแแ แคแแ แแ โ Web-แแ แแแคแฃแซแแแแฃแแ PostgreSQL แแแแแฏแแแแขแแก แฌแแแ แแแฌแแแ, แ แแแแแแช แแแ แแแแแแแก แ แแแแแแแแ แแแแฃแแแแฃแ แแ แแแ แแแแก แแ แแแแแแแชแแแก PostgreSQL-แแแ แแแแแกแแงแแแแแแแ.
แฃแกแแคแ แแฎแแแแ
แแแ แ โ แแแแแชแแแแ แแแแแก แฃแกแแคแ แแฎแแแแแก แแแแแแแฅแขแ. แแแแแชแแแแ แแแแแก แแ แแฅแกแ แกแแแแแ แแแแแก แแแจแแคแแ แแ, แแแจแแคแ แฃแแ แแแแแชแแแแแแก แซแแแแ, SQL แแแแฅแชแแแแแก แแ แแแแแชแแ, แจแแญแ แแก แแแแแแแแแ, honeypots. แแฎแแ แก แฃแญแแ แก แแแแแแขแแก แแฎแแ แแก แแ แแ แแฅแกแแก แแฎแแ แแก ("แแแแญแแแ แแแแ") แแแจแแคแแ แแก. SQL, NoSQL.
แแแแแก แคแแ แแแขแแ แแแ
CodeBuff โ แแแ-แแแแแกแขแแแฃแ แ แแแแแแ แแแญแแแ แแแแฅแแแฃแ แ แกแฌแแแแแก แกแแจแฃแแแแแแ.
แฎแแแก แฃแฌแงแแแก
- แแฅแแแแ แฌแแแแแ แงแแแแแแแแก แแแกแแกแแแแแแแแแ! แแแฎแแแ แฌแแแแแแฎแแ
แฌแแแแแแก แแแแแแแแแแ แแแ แแแแ.
แแฃ แแฅแแแ แแแฅแแ แ แแแแ แแฆแแแฉแแแ แแแแแชแแแแ แแแแแกแแแแก, แแแฎแแแ แแแแแแแ แแ. แแกแแแ แกแแแแแแแแแแ แแแแแฆแแ แแแแแฎแแแฃแ แแแแก - แแแแ แ แแ แแแ แกแแแแแแแแ. แแฃ แแฅแแแ แแแฅแแ แ แแแแ แจแแแแแฎแแ แกแแแฃแแแ แ แคแฃแ แชแแแแแก แจแแฅแแแแกแแแ แแแแแแจแแ แแแแ, แแแฌแแ แแ แแกแแแแช.
แฌแงแแ แ: www.habr.com