fetch config once

remove unused error
skip flakey test
2026-03-23 01:16:30 +00:00 · 2023-04-30 09:19:39 -07:00 · 2023-04-30 09:07:15 -07:00 · 2023-04-30 09:03:32 -07:00 · 2023-04-30 08:23:30 -07:00 · 2023-04-29 08:38:27 -07:00
22 changed files with 102 additions and 1764 deletions
--- a/CONFIG.md
+++ b/CONFIG.md
@@ -188,22 +188,6 @@ default: "admin_pass"

 Password to access the virtual administrative database

-### dns_cache_enabled
-```
-path: general.dns_cache_enabled
-default: false
-```
-When enabled, ip resolutions for server connections specified using hostnames will be cached
-and checked for changes every `dns_max_ttl` seconds. If a change in the host resolution is found
-old ip connections are closed (gracefully) and new connections will start using new ip.
-
-### dns_max_ttl
-```
-path: general.dns_max_ttl
-default: 30
-```
-Specifies how often (in seconds) cached ip addresses for servers are rechecked (see `dns_cache_enabled`).
-
 ## `pools.<pool_name>` Section

 ### pool_mode
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -26,27 +26,6 @@ version = "1.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bddcadddf5e9015d310179a59bb28c4d4b9920ad0f11e8e14dbadf654890c9a6"

-[[package]]
-name = "async-stream"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dad5c83079eae9969be7fadefe640a1c566901f05ff91ab221de4b6f68d9507e"
-dependencies = [
- "async-stream-impl",
- "futures-core",
-]
-
-[[package]]
-name = "async-stream-impl"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10f203db73a71dfa2fb6dd22763990fa26f3d2625a6da2da900d23b87d26be27"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "async-trait"
 version = "0.1.68"
@@ -233,12 +212,6 @@ dependencies = [
 "syn 1.0.109",
 ]

-[[package]]
-name = "data-encoding"
-version = "2.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ee2393c4a91429dffb4bedf19f4d6abf27d8a732c8ce4980305d782e5426d57"
-
 [[package]]
 name = "digest"
 version = "0.10.6"
@@ -250,18 +223,6 @@ dependencies = [
 "subtle",
 ]

-[[package]]
-name = "enum-as-inner"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9720bba047d567ffc8a3cba48bf19126600e249ab7f128e9233e6376976a116"
-dependencies = [
- "heck",
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "env_logger"
 version = "0.10.0"
@@ -314,15 +275,6 @@ version = "1.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"

-[[package]]
-name = "form_urlencoded"
-version = "1.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9c384f161156f5260c24a097c56119f9be8c798586aecc13afbcbe7b7e26bf8"
-dependencies = [
- "percent-encoding",
-]
-
 [[package]]
 name = "futures"
 version = "0.3.28"
@@ -458,12 +410,6 @@ version = "0.12.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"

-[[package]]
-name = "heck"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2540771e65fc8cb83cd6e8a237f70c319bd5c29f78ed1084ba5d50eeac86f7f9"
-
 [[package]]
 name = "hermit-abi"
 version = "0.2.6"
@@ -488,17 +434,6 @@ dependencies = [
 "digest",
 ]

-[[package]]
-name = "hostname"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c731c3e10504cc8ed35cfe2f1db4c9274c3d35fa486e3b31df46f068ef3e867"
-dependencies = [
- "libc",
- "match_cfg",
- "winapi",
-]
-
 [[package]]
 name = "http"
 version = "0.2.9"
@@ -587,27 +522,6 @@ dependencies = [
 "cxx-build",
 ]

-[[package]]
-name = "idna"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "418a0a6fab821475f634efe3ccc45c013f742efe03d853e8d3355d5cb850ecf8"
-dependencies = [
- "matches",
- "unicode-bidi",
- "unicode-normalization",
-]
-
-[[package]]
-name = "idna"
-version = "0.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e14ddfc70884202db2244c223200c204c2bda1bc6e0998d11b5e024d657209e6"
-dependencies = [
- "unicode-bidi",
- "unicode-normalization",
-]
-
 [[package]]
 name = "indexmap"
 version = "1.9.2"
@@ -628,24 +542,6 @@ dependencies = [
 "windows-sys",
 ]

-[[package]]
-name = "ipconfig"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd302af1b90f2463a98fa5ad469fc212c8e3175a41c3068601bfa2727591c5be"
-dependencies = [
- "socket2",
- "widestring",
- "winapi",
- "winreg",
-]
-
-[[package]]
-name = "ipnet"
-version = "2.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f88c5561171189e69df9d98bcf18fd5f9558300f7ea7b801eb8a0fd748bd8745"
-
 [[package]]
 name = "is-terminal"
 version = "0.4.4"
@@ -693,12 +589,6 @@ dependencies = [
 "wasm-bindgen",
 ]

-[[package]]
-name = "lazy_static"
-version = "1.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
-
 [[package]]
 name = "libc"
 version = "0.2.139"
@@ -714,12 +604,6 @@ dependencies = [
 "cc",
 ]

-[[package]]
-name = "linked-hash-map"
-version = "0.5.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
-
 [[package]]
 name = "linux-raw-sys"
 version = "0.1.4"
@@ -745,27 +629,6 @@ dependencies = [
 "cfg-if",
 ]

-[[package]]
-name = "lru-cache"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31e24f1ad8321ca0e8a1e0ac13f23cb668e6f5466c2c57319f6a5cf1cc8e3b1c"
-dependencies = [
- "linked-hash-map",
-]
-
-[[package]]
-name = "match_cfg"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ffbee8634e0d45d258acb448e7eaab3fce7a0a467395d4d9f228e3c1f01fb2e4"
-
-[[package]]
-name = "matches"
-version = "0.1.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a3e378b66a060d48947b590737b30a1be76706c8dd7b8ba0f2fe3989c68a853f"
-
 [[package]]
 name = "md-5"
 version = "0.10.5"
@@ -874,15 +737,9 @@ dependencies = [
 "windows-sys",
 ]

-[[package]]
-name = "percent-encoding"
-version = "2.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e"
-
 [[package]]
 name = "pgcat"
-version = "1.0.2-alpha1"
+version = "1.0.1"
 dependencies = [
 "arc-swap",
 "async-trait",
@@ -913,7 +770,6 @@ dependencies = [
 "rustls-pemfile",
 "serde",
 "serde_derive",
- "serde_json",
 "sha-1",
 "sha2",
 "socket2",
@@ -921,9 +777,7 @@ dependencies = [
 "stringprep",
 "tokio",
 "tokio-rustls",
- "tokio-test",
 "toml",
- "trust-dns-resolver",
 "webpki-roots",
 ]

@@ -1034,12 +888,6 @@ dependencies = [
 "unicode-ident",
 ]

-[[package]]
-name = "quick-error"
-version = "1.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
-
 [[package]]
 name = "quote"
 version = "1.0.26"
@@ -1090,9 +938,9 @@ dependencies = [

 [[package]]
 name = "regex"
-version = "1.8.1"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af83e617f331cc6ae2da5443c602dfa5af81e517212d9d611a5b3ba1777b5370"
+checksum = "ac6cf59af1067a3fb53fbe5c88c053764e930f932be1d71d3ffe032cbe147f59"
 dependencies = [
 "aho-corasick",
 "memchr",
@@ -1101,19 +949,9 @@ dependencies = [

 [[package]]
 name = "regex-syntax"
-version = "0.7.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5996294f19bd3aae0453a862ad728f60e6600695733dd5df01da90c54363a3c"
-
-[[package]]
-name = "resolv-conf"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "52e44394d2086d010551b14b53b1f24e31647570cd1deb0379e2c21b329aba00"
-dependencies = [
- "hostname",
- "quick-error",
-]
+checksum = "b6868896879ba532248f33598de5181522d8b3d9d724dfd230911e1a7d4822f5"

 [[package]]
 name = "ring"
@@ -1146,9 +984,9 @@ dependencies = [

 [[package]]
 name = "rustls"
-version = "0.21.1"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c911ba11bc8433e811ce56fde130ccf32f5127cab0e0194e9c68c5a5b671791e"
+checksum = "07180898a28ed6a7f7ba2311594308f595e3dd2e3c3812fa0a80a47b45f17e5d"
 dependencies = [
 "log",
 "ring",
@@ -1175,12 +1013,6 @@ dependencies = [
 "untrusted",
 ]

-[[package]]
-name = "ryu"
-version = "1.0.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f91339c0467de62360649f8d3e185ca8de4224ff281f66000de5eb2a77a79041"
-
 [[package]]
 name = "scopeguard"
 version = "1.1.0"
@@ -1208,9 +1040,6 @@ name = "serde"
 version = "1.0.160"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bb2f3770c8bce3bcda7e149193a069a0f4365bda1fa5cd88e03bca26afc1216c"
-dependencies = [
- "serde_derive",
-]

 [[package]]
 name = "serde_derive"
@@ -1223,17 +1052,6 @@ dependencies = [
 "syn 2.0.9",
 ]

-[[package]]
-name = "serde_json"
-version = "1.0.96"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "057d394a50403bcac12672b2b18fb387ab6d289d957dab67dd201875391e52f1"
-dependencies = [
- "itoa",
- "ryu",
- "serde",
-]
-
 [[package]]
 name = "serde_spanned"
 version = "0.6.1"
@@ -1318,18 +1136,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "355dc4d4b6207ca8a3434fc587db0a8016130a574dbcdbfb93d7f7b5bc5b211a"
 dependencies = [
 "log",
- "sqlparser_derive",
-]
-
-[[package]]
-name = "sqlparser_derive"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "55fe75cb4a364c7f7ae06c7dbbc8d84bddd85d6cdf9975963c3935bc1991761e"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
 ]

 [[package]]
@@ -1385,26 +1191,6 @@ dependencies = [
 "winapi-util",
 ]

-[[package]]
-name = "thiserror"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "10deb33631e3c9018b9baf9dcbbc4f737320d2b576bac10f6aefa048fa407e3e"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.37"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "982d17546b47146b28f7c22e3d08465f6b8903d0ea13c1660d9d84a6e7adcdbb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "time"
 version = "0.1.45"
@@ -1472,30 +1258,6 @@ dependencies = [
 "tokio",
 ]

-[[package]]
-name = "tokio-stream"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d660770404473ccd7bc9f8b28494a811bc18542b915c0855c51e8f419d5223ce"
-dependencies = [
- "futures-core",
- "pin-project-lite",
- "tokio",
-]
-
-[[package]]
-name = "tokio-test"
-version = "0.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53474327ae5e166530d17f2d956afcb4f8a004de581b3cae10f12006bc8163e3"
-dependencies = [
- "async-stream",
- "bytes",
- "futures-core",
- "tokio",
- "tokio-stream",
-]
-
 [[package]]
 name = "tokio-util"
 version = "0.7.7"
@@ -1558,21 +1320,9 @@ checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8"
 dependencies = [
 "cfg-if",
 "pin-project-lite",
- "tracing-attributes",
 "tracing-core",
 ]

-[[package]]
-name = "tracing-attributes"
-version = "0.1.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "tracing-core"
 version = "0.1.30"
@@ -1582,51 +1332,6 @@ dependencies = [
 "once_cell",
 ]

-[[package]]
-name = "trust-dns-proto"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4f7f83d1e4a0e4358ac54c5c3681e5d7da5efc5a7a632c90bb6d6669ddd9bc26"
-dependencies = [
- "async-trait",
- "cfg-if",
- "data-encoding",
- "enum-as-inner",
- "futures-channel",
- "futures-io",
- "futures-util",
- "idna 0.2.3",
- "ipnet",
- "lazy_static",
- "rand",
- "smallvec",
- "thiserror",
- "tinyvec",
- "tokio",
- "tracing",
- "url",
-]
-
-[[package]]
-name = "trust-dns-resolver"
-version = "0.22.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aff21aa4dcefb0a1afbfac26deb0adc93888c7d295fb63ab273ef276ba2b7cfe"
-dependencies = [
- "cfg-if",
- "futures-util",
- "ipconfig",
- "lazy_static",
- "lru-cache",
- "parking_lot",
- "resolv-conf",
- "smallvec",
- "thiserror",
- "tokio",
- "tracing",
- "trust-dns-proto",
-]
-
 [[package]]
 name = "try-lock"
 version = "0.2.4"
@@ -1672,17 +1377,6 @@ version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"

-[[package]]
-name = "url"
-version = "2.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0d68c799ae75762b8c3fe375feb6600ef5602c883c5d21eb51c09f22b83c4643"
-dependencies = [
- "form_urlencoded",
- "idna 0.3.0",
- "percent-encoding",
-]
-
 [[package]]
 name = "version_check"
 version = "0.9.4"
@@ -1784,12 +1478,6 @@ dependencies = [
 "rustls-webpki",
 ]

-[[package]]
-name = "widestring"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17882f045410753661207383517a6f62ec3dbeb6a4ed2acce01f0728238d1983"
-
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -1895,12 +1583,3 @@ checksum = "faf09497b8f8b5ac5d3bb4d05c0a99be20f26fd3d5f2db7b0716e946d5103658"
 dependencies = [
 "memchr",
 ]
-
-[[package]]
-name = "winreg"
-version = "0.10.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "80d0f4e272c85def139476380b12f9ac60926689dd2e01d4923222f40580869d"
-dependencies = [
- "winapi",
-]
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pgcat"
-version = "1.0.2-alpha1"
+version = "1.0.1"
 edition = "2021"

 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@@ -14,12 +14,12 @@ rand = "0.8"
 chrono = "0.4"
 sha-1 = "0.10"
 toml = "0.7"
-serde = { version = "1", features = ["derive"] }
+serde = "1"
 serde_derive = "1"
 regex = "1"
 num_cpus = "1"
 once_cell = "1"
-sqlparser = {version = "0.33", features = ["visitor"] }
+sqlparser = "0.33.0"
 log = "0.4"
 arc-swap = "1"
 env_logger = "0.10"
@@ -42,10 +42,6 @@ fallible-iterator = "0.2"
 pin-project = "1"
 webpki-roots = "0.23"
 rustls = { version = "0.21", features = ["dangerous_configuration"] }
-trust-dns-resolver = "0.22.0"
-tokio-test = "0.4.2"
-serde_json = "1"

 [target.'cfg(not(target_env = "msvc"))'.dependencies]
 jemallocator = "0.5.0"
-
--- a/README.md
+++ b/README.md
@@ -18,7 +18,7 @@ PostgreSQL pooler and proxy (like PgBouncer) with support for sharding, load bal
 | Failover | **Stable** | Queries are automatically rerouted around broken replicas, validated by regular health checks. |
 | Admin database statistics | **Stable** | Pooler statistics and administration via the `pgbouncer` and `pgcat` databases. |
 | Prometheus statistics | **Stable** | Statistics are reported via a HTTP endpoint for Prometheus. |
-| SSL/TLS | **Stable** | Clients can connect to the pooler using TLS. Pooler can connect to Postgres servers using TLS. |
+| Client TLS | **Stable** | Clients can connect to the pooler using TLS/SSL. |
 | Client/Server authentication | **Stable** | Clients can connect using MD5 authentication, supported by `libpq` and all Postgres client drivers. PgCat can connect to Postgres using MD5 and SCRAM-SHA-256. |
 | Live configuration reloading | **Stable** | Identical to PgBouncer; all settings can be reloaded dynamically (except `host` and `port`). |
 | Auth passthrough | **Stable** | MD5 password authentication can be configured to use an `auth_query` so no cleartext passwords are needed in the config file.|
--- a/pgcat.toml
+++ b/pgcat.toml
@@ -146,53 +146,6 @@ idle_timeout = 40000
 # Connect timeout can be overwritten in the pool
 connect_timeout = 3000

-# When enabled, ip resolutions for server connections specified using hostnames will be cached
-# and checked for changes every `dns_max_ttl` seconds. If a change in the host resolution is found
-# old ip connections are closed (gracefully) and new connections will start using new ip.
-# dns_cache_enabled = false
-
-# Specifies how often (in seconds) cached ip addresses for servers are rechecked (see `dns_cache_enabled`).
-# dns_max_ttl = 30
-
-[plugins]
-
-[plugins.query_logger]
-enabled = false
-
-[plugins.table_access]
-enabled = false
-tables = [
-  "pg_user",
-  "pg_roles",
-  "pg_database",
-]
-
-[plugins.intercept]
-enabled = true
-
-[plugins.intercept.queries.0]
-
-query = "select current_database() as a, current_schemas(false) as b"
-schema = [
-  ["a", "text"],
-  ["b", "text"],
-]
-result = [
-  ["${DATABASE}", "{public}"],
-]
-
-[plugins.intercept.queries.1]
-
-query = "select current_database(), current_schema(), current_user"
-schema = [
-  ["current_database", "text"],
-  ["current_schema", "text"],
-  ["current_user", "text"],
-]
-result = [
-  ["${DATABASE}", "public", "${USER}"],
-]
-
 # User configs are structured as pool.<pool_name>.users.<user_index>
 # This section holds the credentials for users that may connect to this cluster
 [pools.sharded_db.users.0]
--- a/src/admin.rs
+++ b/src/admin.rs
@@ -12,9 +12,9 @@ use tokio::time::Instant;
 use crate::config::{get_config, reload_config, VERSION};
 use crate::errors::Error;
 use crate::messages::*;
-use crate::pool::ClientServerMap;
 use crate::pool::{get_all_pools, get_pool};
 use crate::stats::{get_client_stats, get_pool_stats, get_server_stats, ClientState, ServerState};
+use crate::ClientServerMap;

 pub fn generate_server_info_for_admin() -> BytesMut {
    let mut server_info = BytesMut::new();
--- a/src/client.rs
+++ b/src/client.rs
@@ -16,7 +16,6 @@ use crate::auth_passthrough::refetch_auth_hash;
 use crate::config::{get_config, get_idle_client_in_transaction_timeout, Address, PoolMode};
 use crate::constants::*;
 use crate::messages::*;
-use crate::plugins::PluginOutput;
 use crate::pool::{get_pool, ClientServerMap, ConnectionPool};
 use crate::query_router::{Command, QueryRouter};
 use crate::server::Server;
@@ -766,9 +765,6 @@ where

        self.stats.register(self.stats.clone());

-        // Result returned by one of the plugins.
-        let mut plugin_output = None;
-
        // Our custom protocol loop.
        // We expect the client to either start a transaction with regular queries
        // or issue commands for our sharding and server selection protocol.
@@ -819,25 +815,7 @@ where

                'Q' => {
                    if query_router.query_parser_enabled() {
-                        if let Ok(ast) = QueryRouter::parse(&message) {
-                            let plugin_result = query_router.execute_plugins(&ast).await;
-
-                            match plugin_result {
-                                Ok(PluginOutput::Deny(error)) => {
-                                    error_response(&mut self.write, &error).await?;
-                                    continue;
-                                }
-
-                                Ok(PluginOutput::Intercept(result)) => {
-                                    write_all(&mut self.write, result).await?;
-                                    continue;
-                                }
-
-                                _ => (),
-                            };
-
-                            let _ = query_router.infer(&ast);
-                        }
+                        query_router.infer(&message);
                    }
                }

@@ -845,13 +823,7 @@ where
                    self.buffer.put(&message[..]);

                    if query_router.query_parser_enabled() {
-                        if let Ok(ast) = QueryRouter::parse(&message) {
-                            if let Ok(output) = query_router.execute_plugins(&ast).await {
-                                plugin_output = Some(output);
-                            }
-
-                            let _ = query_router.infer(&ast);
-                        }
+                        query_router.infer(&message);
                    }

                    continue;
@@ -885,18 +857,6 @@ where
                continue;
            }

-            // Check on plugin results.
-            match plugin_output {
-                Some(PluginOutput::Deny(error)) => {
-                    self.buffer.clear();
-                    error_response(&mut self.write, &error).await?;
-                    plugin_output = None;
-                    continue;
-                }
-
-                _ => (),
-            };
-
            // Get a pool instance referenced by the most up-to-date
            // pointer. This ensures we always read the latest config
            // when starting a query.
@@ -1125,27 +1085,6 @@ where
                match code {
                    // Query
                    'Q' => {
-                        if query_router.query_parser_enabled() {
-                            if let Ok(ast) = QueryRouter::parse(&message) {
-                                let plugin_result = query_router.execute_plugins(&ast).await;
-
-                                match plugin_result {
-                                    Ok(PluginOutput::Deny(error)) => {
-                                        error_response(&mut self.write, &error).await?;
-                                        continue;
-                                    }
-
-                                    Ok(PluginOutput::Intercept(result)) => {
-                                        write_all(&mut self.write, result).await?;
-                                        continue;
-                                    }
-
-                                    _ => (),
-                                };
-
-                                let _ = query_router.infer(&ast);
-                            }
-                        }
                        debug!("Sending query to server");

                        self.send_and_receive_loop(
@@ -1185,14 +1124,6 @@ where
                    // Parse
                    // The query with placeholders is here, e.g. `SELECT * FROM users WHERE email = $1 AND active = $2`.
                    'P' => {
-                        if query_router.query_parser_enabled() {
-                            if let Ok(ast) = QueryRouter::parse(&message) {
-                                if let Ok(output) = query_router.execute_plugins(&ast).await {
-                                    plugin_output = Some(output);
-                                }
-                            }
-                        }
-
                        self.buffer.put(&message[..]);
                    }

@@ -1224,24 +1155,6 @@ where
                    'S' => {
                        debug!("Sending query to server");

-                        match plugin_output {
-                            Some(PluginOutput::Deny(error)) => {
-                                error_response(&mut self.write, &error).await?;
-                                plugin_output = None;
-                                self.buffer.clear();
-                                continue;
-                            }
-
-                            Some(PluginOutput::Intercept(result)) => {
-                                write_all(&mut self.write, result).await?;
-                                plugin_output = None;
-                                self.buffer.clear();
-                                continue;
-                            }
-
-                            _ => (),
-                        };
-
                        self.buffer.put(&message[..]);

                        let first_message_code = (*self.buffer.get(0).unwrap_or(&0)) as char;
--- a/src/config.rs
+++ b/src/config.rs
@@ -12,7 +12,6 @@ use std::sync::Arc;
 use tokio::fs::File;
 use tokio::io::AsyncReadExt;

-use crate::dns_cache::CachedResolver;
 use crate::errors::Error;
 use crate::pool::{ClientServerMap, ConnectionPool};
 use crate::sharding::ShardingFunction;
@@ -256,12 +255,6 @@ pub struct General {
    #[serde(default)] // False
    pub log_client_disconnections: bool,

-    #[serde(default)] // False
-    pub dns_cache_enabled: bool,
-
-    #[serde(default = "General::default_dns_max_ttl")]
-    pub dns_max_ttl: u64,
-
    #[serde(default = "General::default_shutdown_timeout")]
    pub shutdown_timeout: u64,

@@ -298,7 +291,6 @@ pub struct General {
    pub admin_username: String,
    pub admin_password: String,

-    // Support for auth query
    pub auth_query: Option<String>,
    pub auth_query_user: Option<String>,
    pub auth_query_password: Option<String>,
@@ -344,10 +336,6 @@ impl General {
        60000
    }

-    pub fn default_dns_max_ttl() -> u64 {
-        30
-    }
-
    pub fn default_healthcheck_timeout() -> u64 {
        1000
    }
@@ -390,8 +378,6 @@ impl Default for General {
            log_client_connections: false,
            log_client_disconnections: false,
            autoreload: None,
-            dns_cache_enabled: false,
-            dns_max_ttl: Self::default_dns_max_ttl(),
            tls_certificate: None,
            tls_private_key: None,
            server_tls: false,
@@ -679,56 +665,6 @@ impl Default for Shard {
    }
 }

-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
-pub struct Plugins {
-    pub intercept: Option<Intercept>,
-    pub table_access: Option<TableAccess>,
-    pub query_logger: Option<QueryLogger>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
-pub struct Intercept {
-    pub enabled: bool,
-    pub queries: BTreeMap<String, Query>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
-pub struct TableAccess {
-    pub enabled: bool,
-    pub tables: Vec<String>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
-pub struct QueryLogger {
-    pub enabled: bool,
-}
-
-impl Intercept {
-    pub fn substitute(&mut self, db: &str, user: &str) {
-        for (_, query) in self.queries.iter_mut() {
-            query.substitute(db, user);
-            query.query = query.query.to_ascii_lowercase();
-        }
-    }
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Default)]
-pub struct Query {
-    pub query: String,
-    pub schema: Vec<Vec<String>>,
-    pub result: Vec<Vec<String>>,
-}
-
-impl Query {
-    pub fn substitute(&mut self, db: &str, user: &str) {
-        for col in self.result.iter_mut() {
-            for i in 0..col.len() {
-                col[i] = col[i].replace("${USER}", user).replace("${DATABASE}", db);
-            }
-        }
-    }
-}
-
 /// Configuration wrapper.
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 pub struct Config {
@@ -747,7 +683,6 @@ pub struct Config {
    pub path: String,

    pub general: General,
-    pub plugins: Option<Plugins>,
    pub pools: HashMap<String, Pool>,
 }

@@ -785,7 +720,6 @@ impl Default for Config {
            path: Self::default_path(),
            general: General::default(),
            pools: HashMap::default(),
-            plugins: None,
        }
    }
 }
@@ -1177,7 +1111,6 @@ pub async fn parse(path: &str) -> Result<(), Error> {

 pub async fn reload_config(client_server_map: ClientServerMap) -> Result<bool, Error> {
    let old_config = get_config();
-
    match parse(&old_config.path).await {
        Ok(()) => (),
        Err(err) => {
@@ -1185,18 +1118,14 @@ pub async fn reload_config(client_server_map: ClientServerMap) -> Result<bool, E
            return Err(Error::BadConfig);
        }
    };
-
    let new_config = get_config();

-    match CachedResolver::from_config().await {
-        Ok(_) => (),
-        Err(err) => error!("DNS cache reinitialization error: {:?}", err),
-    };
-
-    if old_config != new_config {
-        info!("Config changed, reloading");
+    if old_config.pools != new_config.pools {
+        info!("Pool configuration changed");
        ConnectionPool::from_config(client_server_map).await?;
        Ok(true)
+    } else if old_config != new_config {
+        Ok(true)
    } else {
        Ok(false)
    }
--- a/src/dns_cache.rs
+++ b/src/dns_cache.rs
@@ -1,410 +0,0 @@
-use crate::config::get_config;
-use crate::errors::Error;
-use arc_swap::ArcSwap;
-use log::{debug, error, info, warn};
-use once_cell::sync::Lazy;
-use std::collections::{HashMap, HashSet};
-use std::io;
-use std::net::IpAddr;
-use std::sync::Arc;
-use std::sync::RwLock;
-use tokio::time::{sleep, Duration};
-use trust_dns_resolver::error::{ResolveError, ResolveResult};
-use trust_dns_resolver::lookup_ip::LookupIp;
-use trust_dns_resolver::TokioAsyncResolver;
-
-/// Cached Resolver Globally available
-pub static CACHED_RESOLVER: Lazy<ArcSwap<CachedResolver>> =
-    Lazy::new(|| ArcSwap::from_pointee(CachedResolver::default()));
-
-// Ip addressed are returned as a set of addresses
-// so we can compare.
-#[derive(Clone, PartialEq, Debug)]
-pub struct AddrSet {
-    set: HashSet<IpAddr>,
-}
-
-impl AddrSet {
-    fn new() -> AddrSet {
-        AddrSet {
-            set: HashSet::new(),
-        }
-    }
-}
-
-impl From<LookupIp> for AddrSet {
-    fn from(lookup_ip: LookupIp) -> Self {
-        let mut addr_set = AddrSet::new();
-        for address in lookup_ip.iter() {
-            addr_set.set.insert(address);
-        }
-        addr_set
-    }
-}
-
-///
-/// A CachedResolver is a DNS resolution cache mechanism with customizable expiration time.
-///
-/// The system works as follows:
-///
-/// When a host is to be resolved, if we have not resolved it before, a new resolution is
-/// executed and stored in the internal cache. Concurrently, every `dns_max_ttl` time, the
-/// cache is refreshed.
-///
-/// # Example:
-///
-/// ```
-/// use pgcat::dns_cache::{CachedResolverConfig, CachedResolver};
-///
-/// # tokio_test::block_on(async {
-/// let config = CachedResolverConfig::default();
-/// let resolver = CachedResolver::new(config, None).await.unwrap();
-/// let addrset = resolver.lookup_ip("www.example.com.").await.unwrap();
-/// # })
-/// ```
-///
-/// // Now the ip resolution is stored in local cache and subsequent
-/// // calls will be returned from cache. Also, the cache is refreshed
-/// // and updated every 10 seconds.
-///
-/// // You can now check if an 'old' lookup differs from what it's currently
-/// // store in cache by using `has_changed`.
-/// resolver.has_changed("www.example.com.", addrset)
-#[derive(Default)]
-pub struct CachedResolver {
-    // The configuration of the cached_resolver.
-    config: CachedResolverConfig,
-
-    // This is the hash that contains the hash.
-    data: Option<RwLock<HashMap<String, AddrSet>>>,
-
-    // The resolver to be used for DNS queries.
-    resolver: Option<TokioAsyncResolver>,
-
-    // The RefreshLoop
-    refresh_loop: RwLock<Option<tokio::task::JoinHandle<()>>>,
-}
-
-///
-/// Configuration
-#[derive(Clone, Debug, Default, PartialEq)]
-pub struct CachedResolverConfig {
-    /// Amount of time in secods that a resolved dns address is considered stale.
-    dns_max_ttl: u64,
-
-    /// Enabled or disabled? (this is so we can reload config)
-    enabled: bool,
-}
-
-impl CachedResolverConfig {
-    fn new(dns_max_ttl: u64, enabled: bool) -> Self {
-        CachedResolverConfig {
-            dns_max_ttl,
-            enabled,
-        }
-    }
-}
-
-impl From<crate::config::Config> for CachedResolverConfig {
-    fn from(config: crate::config::Config) -> Self {
-        CachedResolverConfig::new(config.general.dns_max_ttl, config.general.dns_cache_enabled)
-    }
-}
-
-impl CachedResolver {
-    ///
-    /// Returns a new Arc<CachedResolver> based on passed configuration.
-    /// It also starts the loop that will refresh cache entries.
-    ///
-    /// # Arguments:
-    ///
-    /// * `config` - The `CachedResolverConfig` to be used to create the resolver.
-    ///
-    /// # Example:
-    ///
-    /// ```
-    /// use pgcat::dns_cache::{CachedResolverConfig, CachedResolver};
-    ///
-    /// # tokio_test::block_on(async {
-    /// let config = CachedResolverConfig::default();
-    /// let resolver = CachedResolver::new(config, None).await.unwrap();
-    /// # })
-    /// ```
-    ///
-    pub async fn new(
-        config: CachedResolverConfig,
-        data: Option<HashMap<String, AddrSet>>,
-    ) -> Result<Arc<Self>, io::Error> {
-        // Construct a new Resolver with default configuration options
-        let resolver = Some(TokioAsyncResolver::tokio_from_system_conf()?);
-
-        let data = if let Some(hash) = data {
-            Some(RwLock::new(hash))
-        } else {
-            Some(RwLock::new(HashMap::new()))
-        };
-
-        let instance = Arc::new(Self {
-            config,
-            resolver,
-            data,
-            refresh_loop: RwLock::new(None),
-        });
-
-        if instance.enabled() {
-            info!("Scheduling DNS refresh loop");
-            let refresh_loop = tokio::task::spawn({
-                let instance = instance.clone();
-                async move {
-                    instance.refresh_dns_entries_loop().await;
-                }
-            });
-            *(instance.refresh_loop.write().unwrap()) = Some(refresh_loop);
-        }
-
-        Ok(instance)
-    }
-
-    pub fn enabled(&self) -> bool {
-        self.config.enabled
-    }
-
-    // Schedules the refresher
-    async fn refresh_dns_entries_loop(&self) {
-        let resolver = TokioAsyncResolver::tokio_from_system_conf().unwrap();
-        let interval = Duration::from_secs(self.config.dns_max_ttl);
-        loop {
-            debug!("Begin refreshing cached DNS addresses.");
-            // To minimize the time we hold the lock, we first create
-            // an array with keys.
-            let mut hostnames: Vec<String> = Vec::new();
-            {
-                if let Some(ref data) = self.data {
-                    for hostname in data.read().unwrap().keys() {
-                        hostnames.push(hostname.clone());
-                    }
-                }
-            }
-
-            for hostname in hostnames.iter() {
-                let addrset = self
-                    .fetch_from_cache(hostname.as_str())
-                    .expect("Could not obtain expected address from cache, this should not happen");
-
-                match resolver.lookup_ip(hostname).await {
-                    Ok(lookup_ip) => {
-                        let new_addrset = AddrSet::from(lookup_ip);
-                        debug!(
-                            "Obtained address for host ({}) -> ({:?})",
-                            hostname, new_addrset
-                        );
-
-                        if addrset != new_addrset {
-                            debug!(
-                                "Addr changed from {:?} to {:?} updating cache.",
-                                addrset, new_addrset
-                            );
-                            self.store_in_cache(hostname, new_addrset);
-                        }
-                    }
-                    Err(err) => {
-                        error!(
-                            "There was an error trying to resolv {}: ({}).",
-                            hostname, err
-                        );
-                    }
-                }
-            }
-            debug!("Finished refreshing cached DNS addresses.");
-            sleep(interval).await;
-        }
-    }
-
-    /// Returns a `AddrSet` given the specified hostname.
-    ///
-    /// This method first tries to fetch the value from the cache, if it misses
-    /// then it is resolved and stored in the cache. TTL from records is ignored.
-    ///
-    /// # Arguments
-    ///
-    /// * `host`      - A string slice referencing the hostname to be resolved.
-    ///
-    /// # Example:
-    ///
-    /// ```
-    /// use pgcat::dns_cache::{CachedResolverConfig, CachedResolver};
-    ///
-    /// # tokio_test::block_on(async {
-    /// let config = CachedResolverConfig::default();
-    /// let resolver = CachedResolver::new(config, None).await.unwrap();
-    /// let response = resolver.lookup_ip("www.google.com.");
-    /// # })
-    /// ```
-    ///
-    pub async fn lookup_ip(&self, host: &str) -> ResolveResult<AddrSet> {
-        debug!("Lookup up {} in cache", host);
-        match self.fetch_from_cache(host) {
-            Some(addr_set) => {
-                debug!("Cache hit!");
-                Ok(addr_set)
-            }
-            None => {
-                debug!("Not found, executing a dns query!");
-                if let Some(ref resolver) = self.resolver {
-                    let addr_set = AddrSet::from(resolver.lookup_ip(host).await?);
-                    debug!("Obtained: {:?}", addr_set);
-                    self.store_in_cache(host, addr_set.clone());
-                    Ok(addr_set)
-                } else {
-                    Err(ResolveError::from("No resolver available"))
-                }
-            }
-        }
-    }
-
-    //
-    // Returns true if the stored host resolution differs from the AddrSet passed.
-    pub fn has_changed(&self, host: &str, addr_set: &AddrSet) -> bool {
-        if let Some(fetched_addr_set) = self.fetch_from_cache(host) {
-            return fetched_addr_set != *addr_set;
-        }
-        false
-    }
-
-    // Fetches an AddrSet from the inner cache adquiring the read lock.
-    fn fetch_from_cache(&self, key: &str) -> Option<AddrSet> {
-        if let Some(ref hash) = self.data {
-            if let Some(addr_set) = hash.read().unwrap().get(key) {
-                return Some(addr_set.clone());
-            }
-        }
-        None
-    }
-
-    // Sets up the global CACHED_RESOLVER static variable so we can globally use DNS
-    // cache.
-    pub async fn from_config() -> Result<(), Error> {
-        let cached_resolver = CACHED_RESOLVER.load();
-        let desired_config = CachedResolverConfig::from(get_config());
-
-        if cached_resolver.config != desired_config {
-            if let Some(ref refresh_loop) = *(cached_resolver.refresh_loop.write().unwrap()) {
-                warn!("Killing Dnscache refresh loop as its configuration is being reloaded");
-                refresh_loop.abort()
-            }
-            let new_resolver = if let Some(ref data) = cached_resolver.data {
-                let data = Some(data.read().unwrap().clone());
-                CachedResolver::new(desired_config, data).await
-            } else {
-                CachedResolver::new(desired_config, None).await
-            };
-
-            match new_resolver {
-                Ok(ok) => {
-                    CACHED_RESOLVER.store(ok);
-                    Ok(())
-                }
-                Err(err) => {
-                    let message = format!("Error setting up cached_resolver. Error: {:?}, will continue without this feature.", err);
-                    Err(Error::DNSCachedError(message))
-                }
-            }
-        } else {
-            Ok(())
-        }
-    }
-
-    // Stores the AddrSet in cache adquiring the write lock.
-    fn store_in_cache(&self, host: &str, addr_set: AddrSet) {
-        if let Some(ref data) = self.data {
-            data.write().unwrap().insert(host.to_string(), addr_set);
-        } else {
-            error!("Could not insert, Hash not initialized");
-        }
-    }
-}
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use trust_dns_resolver::error::ResolveError;
-
-    #[tokio::test]
-    async fn new() {
-        let config = CachedResolverConfig {
-            dns_max_ttl: 10,
-            enabled: true,
-        };
-        let resolver = CachedResolver::new(config, None).await;
-        assert!(resolver.is_ok());
-    }
-
-    #[tokio::test]
-    async fn lookup_ip() {
-        let config = CachedResolverConfig {
-            dns_max_ttl: 10,
-            enabled: true,
-        };
-        let resolver = CachedResolver::new(config, None).await.unwrap();
-        let response = resolver.lookup_ip("www.google.com.").await;
-        assert!(response.is_ok());
-    }
-
-    #[tokio::test]
-    async fn has_changed() {
-        let config = CachedResolverConfig {
-            dns_max_ttl: 10,
-            enabled: true,
-        };
-        let resolver = CachedResolver::new(config, None).await.unwrap();
-        let hostname = "www.google.com.";
-        let response = resolver.lookup_ip(hostname).await;
-        let addr_set = response.unwrap();
-        assert!(!resolver.has_changed(hostname, &addr_set));
-    }
-
-    #[tokio::test]
-    async fn unknown_host() {
-        let config = CachedResolverConfig {
-            dns_max_ttl: 10,
-            enabled: true,
-        };
-        let resolver = CachedResolver::new(config, None).await.unwrap();
-        let hostname = "www.idontexists.";
-        let response = resolver.lookup_ip(hostname).await;
-        assert!(matches!(response, Err(ResolveError { .. })));
-    }
-
-    #[tokio::test]
-    async fn incorrect_address() {
-        let config = CachedResolverConfig {
-            dns_max_ttl: 10,
-            enabled: true,
-        };
-        let resolver = CachedResolver::new(config, None).await.unwrap();
-        let hostname = "w  ww.idontexists.";
-        let response = resolver.lookup_ip(hostname).await;
-        assert!(matches!(response, Err(ResolveError { .. })));
-        assert!(!resolver.has_changed(hostname, &AddrSet::new()));
-    }
-
-    #[tokio::test]
-    // Ok, this test is based on the fact that google does DNS RR
-    // and does not responds with every available ip everytime, so
-    // if I cache here, it will miss after one cache iteration or two.
-    async fn thread() {
-        let config = CachedResolverConfig {
-            dns_max_ttl: 10,
-            enabled: true,
-        };
-        let resolver = CachedResolver::new(config, None).await.unwrap();
-        let hostname = "www.google.com.";
-        let response = resolver.lookup_ip(hostname).await;
-        let addr_set = response.unwrap();
-        assert!(!resolver.has_changed(hostname, &addr_set));
-        let resolver_for_refresher = resolver.clone();
-        let _thread_handle = tokio::task::spawn(async move {
-            resolver_for_refresher.refresh_dns_entries_loop().await;
-        });
-        assert!(!resolver.has_changed(hostname, &addr_set));
-    }
-}
--- a/src/errors.rs
+++ b/src/errors.rs
@@ -1,7 +1,7 @@
 //! Errors.

 /// Various errors.
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq)]
 pub enum Error {
    SocketError(String),
    ClientSocketError(String, ClientIdentifier),
@@ -19,13 +19,10 @@ pub enum Error {
    ClientError(String),
    TlsError,
    StatementTimeout,
-    DNSCachedError(String),
    ShuttingDown,
    ParseBytesError(String),
    AuthError(String),
    AuthPassthroughError(String),
-    UnsupportedStatement,
-    QueryRouterParserError(String),
 }

 #[derive(Clone, PartialEq, Debug)]
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,17 +1,11 @@
-pub mod admin;
 pub mod auth_passthrough;
-pub mod client;
 pub mod config;
 pub mod constants;
-pub mod dns_cache;
 pub mod errors;
 pub mod messages;
 pub mod mirrors;
 pub mod multi_logger;
-pub mod plugins;
 pub mod pool;
-pub mod prometheus;
-pub mod query_router;
 pub mod scram;
 pub mod server;
 pub mod sharding;
--- a/src/main.rs
+++ b/src/main.rs
@@ -36,7 +36,6 @@ extern crate sqlparser;
 extern crate tokio;
 extern crate tokio_rustls;
 extern crate toml;
-extern crate trust_dns_resolver;

 #[cfg(not(target_env = "msvc"))]
 use jemallocator::Jemalloc;
@@ -61,19 +60,36 @@ use std::str::FromStr;
 use std::sync::Arc;
 use tokio::sync::broadcast;

-use pgcat::config::{get_config, reload_config, VERSION};
-use pgcat::dns_cache;
-use pgcat::messages::configure_socket;
-use pgcat::pool::{ClientServerMap, ConnectionPool};
-use pgcat::prometheus::start_metric_server;
-use pgcat::stats::{Collector, Reporter, REPORTER};
+mod admin;
+mod auth_passthrough;
+mod client;
+mod config;
+mod constants;
+mod errors;
+mod messages;
+mod mirrors;
+mod multi_logger;
+mod pool;
+mod prometheus;
+mod query_router;
+mod scram;
+mod server;
+mod sharding;
+mod stats;
+mod tls;
+
+use crate::config::{get_config, reload_config, VERSION};
+use crate::messages::configure_socket;
+use crate::pool::{ClientServerMap, ConnectionPool};
+use crate::prometheus::start_metric_server;
+use crate::stats::{Collector, Reporter, REPORTER};

 fn main() -> Result<(), Box<dyn std::error::Error>> {
-    pgcat::multi_logger::MultiLogger::init().unwrap();
+    multi_logger::MultiLogger::init().unwrap();

    info!("Welcome to PgCat! Meow. (Version {})", VERSION);

-    if !pgcat::query_router::QueryRouter::setup() {
+    if !query_router::QueryRouter::setup() {
        error!("Could not setup query router");
        std::process::exit(exitcode::CONFIG);
    }
@@ -91,7 +107,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
        let runtime = Builder::new_multi_thread().worker_threads(1).build()?;

        runtime.block_on(async {
-            match pgcat::config::parse(&config_file).await {
+            match config::parse(&config_file).await {
                Ok(_) => (),
                Err(err) => {
                    error!("Config parse error: {:?}", err);
@@ -150,12 +166,6 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
        // Statistics reporting.
        REPORTER.store(Arc::new(Reporter::default()));

-        // Starts (if enabled) dns cache before pools initialization
-        match dns_cache::CachedResolver::from_config().await {
-                Ok(_) => (),
-                Err(err) => error!("DNS cache initialization error: {:?}", err),
-        };
-
        // Connection pool that allows to query all shards and replicas.
        match ConnectionPool::from_config(client_server_map.clone()).await {
            Ok(_) => (),
@@ -285,7 +295,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
                    tokio::task::spawn(async move {
                        let start = chrono::offset::Utc::now().naive_utc();

-                        match pgcat::client::client_entrypoint(
+                        match client::client_entrypoint(
                            socket,
                            client_server_map,
                            shutdown_rx,
@@ -316,7 +326,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {

                            Err(err) => {
                                match err {
-                                    pgcat::errors::Error::ClientBadStartup => debug!("Client disconnected with error {:?}", err),
+                                    errors::Error::ClientBadStartup => debug!("Client disconnected with error {:?}", err),
                                    _ => warn!("Client disconnected with error {:?}", err),
                                }

--- a/src/messages.rs
+++ b/src/messages.rs
@@ -20,10 +20,6 @@ pub enum DataType {
    Text,
    Int4,
    Numeric,
-    Bool,
-    Oid,
-    AnyArray,
-    Any,
 }

 impl From<&DataType> for i32 {
@@ -32,10 +28,6 @@ impl From<&DataType> for i32 {
            DataType::Text => 25,
            DataType::Int4 => 23,
            DataType::Numeric => 1700,
-            DataType::Bool => 16,
-            DataType::Oid => 26,
-            DataType::AnyArray => 2277,
-            DataType::Any => 2276,
        }
    }
 }
@@ -451,10 +443,6 @@ pub fn row_description(columns: &Vec<(&str, DataType)>) -> BytesMut {
            DataType::Text => -1,
            DataType::Int4 => 4,
            DataType::Numeric => -1,
-            DataType::Bool => 1,
-            DataType::Oid => 4,
-            DataType::AnyArray => -1,
-            DataType::Any => -1,
        };

        row_desc.put_i16(type_size);
@@ -493,29 +481,6 @@ pub fn data_row(row: &Vec<String>) -> BytesMut {
    res
 }

-pub fn data_row_nullable(row: &Vec<Option<String>>) -> BytesMut {
-    let mut res = BytesMut::new();
-    let mut data_row = BytesMut::new();
-
-    data_row.put_i16(row.len() as i16);
-
-    for column in row {
-        if let Some(column) = column {
-            let column = column.as_bytes();
-            data_row.put_i32(column.len() as i32);
-            data_row.put_slice(column);
-        } else {
-            data_row.put_i32(-1 as i32);
-        }
-    }
-
-    res.put_u8(b'D');
-    res.put_i32(data_row.len() as i32 + 4);
-    res.put(data_row);
-
-    res
-}
-
 /// Create a CommandComplete message.
 pub fn command_complete(command: &str) -> BytesMut {
    let cmd = BytesMut::from(format!("{}\0", command).as_bytes());
--- a/src/plugins/intercept.rs
+++ b/src/plugins/intercept.rs
@@ -1,288 +0,0 @@
-//! The intercept plugin.
-//!
-//! It intercepts queries and returns fake results.
-
-use arc_swap::ArcSwap;
-use async_trait::async_trait;
-use bytes::{BufMut, BytesMut};
-use once_cell::sync::Lazy;
-use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
-use sqlparser::ast::Statement;
-use std::collections::HashMap;
-
-use log::{debug, info};
-use std::sync::Arc;
-
-use crate::{
-    config::Intercept as InterceptConfig,
-    errors::Error,
-    messages::{command_complete, data_row_nullable, row_description, DataType},
-    plugins::{Plugin, PluginOutput},
-    pool::{PoolIdentifier, PoolMap},
-    query_router::QueryRouter,
-};
-
-pub static CONFIG: Lazy<ArcSwap<HashMap<PoolIdentifier, InterceptConfig>>> =
-    Lazy::new(|| ArcSwap::from_pointee(HashMap::new()));
-
-/// Check if the interceptor plugin has been enabled.
-pub fn enabled() -> bool {
-    !CONFIG.load().is_empty()
-}
-
-pub fn setup(intercept_config: &InterceptConfig, pools: &PoolMap) {
-    let mut config = HashMap::new();
-    for (identifier, _) in pools.iter() {
-        let mut intercept_config = intercept_config.clone();
-        intercept_config.substitute(&identifier.db, &identifier.user);
-        config.insert(identifier.clone(), intercept_config);
-    }
-
-    CONFIG.store(Arc::new(config));
-
-    info!("Intercepting {} queries", intercept_config.queries.len());
-}
-
-pub fn disable() {
-    CONFIG.store(Arc::new(HashMap::new()));
-}
-
-// TODO: use these structs for deserialization
-#[derive(Serialize, Deserialize)]
-pub struct Rule {
-    query: String,
-    schema: Vec<Column>,
-    result: Vec<Vec<String>>,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct Column {
-    name: String,
-    data_type: String,
-}
-
-/// The intercept plugin.
-pub struct Intercept;
-
-#[async_trait]
-impl Plugin for Intercept {
-    async fn run(
-        &mut self,
-        query_router: &QueryRouter,
-        ast: &Vec<Statement>,
-    ) -> Result<PluginOutput, Error> {
-        if ast.is_empty() {
-            return Ok(PluginOutput::Allow);
-        }
-
-        let mut result = BytesMut::new();
-        let query_map = match CONFIG.load().get(&PoolIdentifier::new(
-            &query_router.pool_settings().db,
-            &query_router.pool_settings().user.username,
-        )) {
-            Some(query_map) => query_map.clone(),
-            None => return Ok(PluginOutput::Allow),
-        };
-
-        for q in ast {
-            // Normalization
-            let q = q.to_string().to_ascii_lowercase();
-
-            for (_, target) in query_map.queries.iter() {
-                if target.query.as_str() == q {
-                    debug!("Intercepting query: {}", q);
-
-                    let rd = target
-                        .schema
-                        .iter()
-                        .map(|row| {
-                            let name = &row[0];
-                            let data_type = &row[1];
-                            (
-                                name.as_str(),
-                                match data_type.as_str() {
-                                    "text" => DataType::Text,
-                                    "anyarray" => DataType::AnyArray,
-                                    "oid" => DataType::Oid,
-                                    "bool" => DataType::Bool,
-                                    "int4" => DataType::Int4,
-                                    _ => DataType::Any,
-                                },
-                            )
-                        })
-                        .collect::<Vec<(&str, DataType)>>();
-
-                    result.put(row_description(&rd));
-
-                    target.result.iter().for_each(|row| {
-                        let row = row
-                            .iter()
-                            .map(|s| {
-                                let s = s.as_str().to_string();
-
-                                if s == "" {
-                                    None
-                                } else {
-                                    Some(s)
-                                }
-                            })
-                            .collect::<Vec<Option<String>>>();
-                        result.put(data_row_nullable(&row));
-                    });
-
-                    result.put(command_complete("SELECT"));
-                }
-            }
-        }
-
-        if !result.is_empty() {
-            result.put_u8(b'Z');
-            result.put_i32(5);
-            result.put_u8(b'I');
-
-            return Ok(PluginOutput::Intercept(result));
-        } else {
-            Ok(PluginOutput::Allow)
-        }
-    }
-}
-
-/// Make IntelliJ SQL plugin believe it's talking to an actual database
-/// instead of PgCat.
-#[allow(dead_code)]
-fn fool_datagrip(database: &str, user: &str) -> Value {
-    json!([
-        {
-            "query": "select current_database() as a, current_schemas(false) as b",
-            "schema": [
-                {
-                    "name": "a",
-                    "data_type": "text",
-                },
-                {
-                    "name": "b",
-                    "data_type": "anyarray",
-                },
-            ],
-
-            "result": [
-                [database, "{public}"],
-            ],
-        },
-        {
-            "query": "select current_database(), current_schema(), current_user",
-            "schema": [
-                {
-                    "name": "current_database",
-                    "data_type": "text",
-                },
-                {
-                    "name": "current_schema",
-                    "data_type": "text",
-                },
-                {
-                    "name": "current_user",
-                    "data_type": "text",
-                }
-            ],
-
-            "result": [
-                ["sharded_db", "public", "sharding_user"],
-            ],
-        },
-        {
-            "query": "select cast(n.oid as bigint) as id, datname as name, d.description, datistemplate as is_template, datallowconn as allow_connections, pg_catalog.pg_get_userbyid(n.datdba) as \"owner\" from pg_catalog.pg_database as n left join pg_catalog.pg_shdescription as d on n.oid = d.objoid order by case when datname = pg_catalog.current_database() then -cast(1 as bigint) else cast(n.oid as bigint) end",
-            "schema": [
-                {
-                    "name": "id",
-                    "data_type": "oid",
-                },
-                {
-                    "name": "name",
-                    "data_type": "text",
-                },
-                {
-                    "name": "description",
-                    "data_type": "text",
-                },
-                {
-                    "name": "is_template",
-                    "data_type": "bool",
-                },
-                {
-                    "name": "allow_connections",
-                    "data_type": "bool",
-                },
-                {
-                    "name": "owner",
-                    "data_type": "text",
-                }
-            ],
-            "result": [
-                ["16387", database, "", "f", "t", user],
-            ]
-        },
-        {
-            "query": "select cast(r.oid as bigint) as role_id, rolname as role_name, rolsuper as is_super, rolinherit as is_inherit, rolcreaterole as can_createrole, rolcreatedb as can_createdb, rolcanlogin as can_login, rolreplication as is_replication, rolconnlimit as conn_limit, rolvaliduntil as valid_until, rolbypassrls as bypass_rls, rolconfig as config, d.description from pg_catalog.pg_roles as r left join pg_catalog.pg_shdescription as d on d.objoid = r.oid",
-            "schema": [
-                {
-                    "name": "role_id",
-                    "data_type": "oid",
-                },
-                {
-                    "name": "role_name",
-                    "data_type": "text",
-                },
-                {
-                    "name": "is_super",
-                    "data_type": "bool",
-                },
-                {
-                    "name": "is_inherit",
-                    "data_type": "bool",
-                },
-                {
-                    "name": "can_createrole",
-                    "data_type": "bool",
-                },
-                {
-                    "name": "can_createdb",
-                    "data_type": "bool",
-                },
-                {
-                    "name": "can_login",
-                    "data_type": "bool",
-                },
-                {
-                    "name": "is_replication",
-                    "data_type": "bool",
-                },
-                {
-                    "name": "conn_limit",
-                    "data_type": "int4",
-                },
-                {
-                    "name": "valid_until",
-                    "data_type": "text",
-                },
-                {
-                    "name": "bypass_rls",
-                    "data_type": "bool",
-                },
-                {
-                    "name": "config",
-                    "data_type": "text",
-                },
-                {
-                    "name": "description",
-                    "data_type": "text",
-                },
-            ],
-            "result": [
-                ["10", "postgres", "f", "t", "f", "f", "t", "f", "-1", "", "f", "", ""],
-                ["16419", user, "f", "t", "f", "f", "t", "f", "-1", "", "f", "", ""],
-            ]
-        }
-    ])
-}
--- a/src/plugins/mod.rs
+++ b/src/plugins/mod.rs
@@ -1,43 +0,0 @@
-//! The plugin ecosystem.
-//!
-//! Currently plugins only grant access or deny access to the database for a particual query.
-//! Example use cases:
-//!   - block known bad queries
-//!   - block access to system catalogs
-//!   - block dangerous modifications like `DROP TABLE`
-//!   - etc
-//!
-
-pub mod intercept;
-pub mod query_logger;
-pub mod table_access;
-
-use crate::{errors::Error, query_router::QueryRouter};
-use async_trait::async_trait;
-use bytes::BytesMut;
-use sqlparser::ast::Statement;
-
-pub use intercept::Intercept;
-pub use query_logger::QueryLogger;
-pub use table_access::TableAccess;
-
-#[derive(Clone, Debug, PartialEq)]
-pub enum PluginOutput {
-    Allow,
-    Deny(String),
-    Overwrite(Vec<Statement>),
-    Intercept(BytesMut),
-}
-
-#[async_trait]
-pub trait Plugin {
-    // Run before the query is sent to the server.
-    async fn run(
-        &mut self,
-        query_router: &QueryRouter,
-        ast: &Vec<Statement>,
-    ) -> Result<PluginOutput, Error>;
-
-    // TODO: run after the result is returned
-    // async fn callback(&mut self, query_router: &QueryRouter);
-}
--- a/src/plugins/query_logger.rs
+++ b/src/plugins/query_logger.rs
@@ -1,49 +0,0 @@
-//! Log all queries to stdout (or somewhere else, why not).
-
-use crate::{
-    errors::Error,
-    plugins::{Plugin, PluginOutput},
-    query_router::QueryRouter,
-};
-use arc_swap::ArcSwap;
-use async_trait::async_trait;
-use log::info;
-use once_cell::sync::Lazy;
-use sqlparser::ast::Statement;
-use std::sync::Arc;
-
-static ENABLED: Lazy<ArcSwap<bool>> = Lazy::new(|| ArcSwap::from_pointee(false));
-
-pub struct QueryLogger;
-
-pub fn setup() {
-    ENABLED.store(Arc::new(true));
-
-    info!("Logging queries to stdout");
-}
-
-pub fn disable() {
-    ENABLED.store(Arc::new(false));
-}
-
-pub fn enabled() -> bool {
-    **ENABLED.load()
-}
-
-#[async_trait]
-impl Plugin for QueryLogger {
-    async fn run(
-        &mut self,
-        _query_router: &QueryRouter,
-        ast: &Vec<Statement>,
-    ) -> Result<PluginOutput, Error> {
-        let query = ast
-            .iter()
-            .map(|q| q.to_string())
-            .collect::<Vec<String>>()
-            .join("; ");
-        info!("{}", query);
-
-        Ok(PluginOutput::Allow)
-    }
-}
--- a/src/plugins/table_access.rs
+++ b/src/plugins/table_access.rs
@@ -1,73 +0,0 @@
-//! This query router plugin will check if the user can access a particular
-//! table as part of their query. If they can't, the query will not be routed.
-
-use async_trait::async_trait;
-use sqlparser::ast::{visit_relations, Statement};
-
-use crate::{
-    config::TableAccess as TableAccessConfig,
-    errors::Error,
-    plugins::{Plugin, PluginOutput},
-    query_router::QueryRouter,
-};
-
-use log::{debug, info};
-
-use arc_swap::ArcSwap;
-use core::ops::ControlFlow;
-use once_cell::sync::Lazy;
-use std::sync::Arc;
-
-static CONFIG: Lazy<ArcSwap<Vec<String>>> = Lazy::new(|| ArcSwap::from_pointee(vec![]));
-
-pub fn setup(config: &TableAccessConfig) {
-    CONFIG.store(Arc::new(config.tables.clone()));
-
-    info!("Blocking access to {} tables", config.tables.len());
-}
-
-pub fn enabled() -> bool {
-    !CONFIG.load().is_empty()
-}
-
-pub fn disable() {
-    CONFIG.store(Arc::new(vec![]));
-}
-
-pub struct TableAccess;
-
-#[async_trait]
-impl Plugin for TableAccess {
-    async fn run(
-        &mut self,
-        _query_router: &QueryRouter,
-        ast: &Vec<Statement>,
-    ) -> Result<PluginOutput, Error> {
-        let mut found = None;
-        let forbidden_tables = CONFIG.load();
-
-        visit_relations(ast, |relation| {
-            let relation = relation.to_string();
-            let parts = relation.split(".").collect::<Vec<&str>>();
-            let table_name = parts.last().unwrap();
-
-            if forbidden_tables.contains(&table_name.to_string()) {
-                found = Some(table_name.to_string());
-                ControlFlow::<()>::Break(())
-            } else {
-                ControlFlow::<()>::Continue(())
-            }
-        });
-
-        if let Some(found) = found {
-            debug!("Blocking access to table \"{}\"", found);
-
-            Ok(PluginOutput::Deny(format!(
-                "permission for table \"{}\" denied",
-                found
-            )))
-        } else {
-            Ok(PluginOutput::Allow)
-        }
-    }
-}
--- a/src/pool.rs
+++ b/src/pool.rs
@@ -61,8 +61,6 @@ pub struct PoolIdentifier {
    pub user: String,
 }

-static POOL_REAPER_RATE: u64 = 30_000; // 30 seconds by default
-
 impl PoolIdentifier {
    /// Create a new user/pool identifier.
    pub fn new(db: &str, user: &str) -> PoolIdentifier {
@@ -93,7 +91,6 @@ pub struct PoolSettings {

    // Connecting user.
    pub user: User,
-    pub db: String,

    // Default server role to connect to.
    pub default_role: Option<Role>,
@@ -141,7 +138,6 @@ impl Default for PoolSettings {
            load_balancing_mode: LoadBalancingMode::Random,
            shards: 1,
            user: User::default(),
-            db: String::default(),
            default_role: None,
            query_parser_enabled: false,
            primary_reads_enabled: true,
@@ -372,20 +368,12 @@ impl ConnectionPool {
                            },
                        };

-                        let reaper_rate = *vec![idle_timeout, server_lifetime, POOL_REAPER_RATE]
-                            .iter()
-                            .min()
-                            .unwrap();
-
-                        debug!("Pool reaper rate: {}ms", reaper_rate);
-
                        let pool = Pool::builder()
                            .max_size(user.pool_size)
                            .min_idle(user.min_pool_size)
                            .connection_timeout(std::time::Duration::from_millis(connect_timeout))
                            .idle_timeout(Some(std::time::Duration::from_millis(idle_timeout)))
                            .max_lifetime(Some(std::time::Duration::from_millis(server_lifetime)))
-                            .reaper_rate(std::time::Duration::from_millis(reaper_rate))
                            .test_on_check_out(false)
                            .build(manager)
                            .await?;
@@ -424,7 +412,6 @@ impl ConnectionPool {
                        // shards: pool_config.shards.clone(),
                        shards: shard_ids.len(),
                        user: user.clone(),
-                        db: pool_name.clone(),
                        default_role: match pool_config.default_role.as_str() {
                            "any" => None,
                            "replica" => Some(Role::Replica),
@@ -469,32 +456,6 @@ impl ConnectionPool {
            }
        }

-        if let Some(ref plugins) = config.plugins {
-            if let Some(ref intercept) = plugins.intercept {
-                if intercept.enabled {
-                    crate::plugins::intercept::setup(intercept, &new_pools);
-                } else {
-                    crate::plugins::intercept::disable();
-                }
-            }
-
-            if let Some(ref table_access) = plugins.table_access {
-                if table_access.enabled {
-                    crate::plugins::table_access::setup(table_access);
-                } else {
-                    crate::plugins::table_access::disable();
-                }
-            }
-
-            if let Some(ref query_logger) = plugins.query_logger {
-                if query_logger.enabled {
-                    crate::plugins::query_logger::setup();
-                } else {
-                    crate::plugins::query_logger::disable();
-                }
-            }
-        }
-
        POOLS.store(Arc::new(new_pools.clone()));
        Ok(())
    }
--- a/src/query_router.rs
+++ b/src/query_router.rs
@@ -6,19 +6,13 @@ use once_cell::sync::OnceCell;
 use regex::{Regex, RegexSet};
 use sqlparser::ast::Statement::{Query, StartTransaction};
 use sqlparser::ast::{
-    BinaryOperator, Expr, Ident, JoinConstraint, JoinOperator, SetExpr, Statement, TableFactor,
-    Value,
+    BinaryOperator, Expr, Ident, JoinConstraint, JoinOperator, SetExpr, TableFactor, Value,
 };
 use sqlparser::dialect::PostgreSqlDialect;
 use sqlparser::parser::Parser;

 use crate::config::Role;
-use crate::errors::Error;
 use crate::messages::BytesMutReader;
-use crate::plugins::{
-    intercept, query_logger, table_access, Intercept, Plugin, PluginOutput, QueryLogger,
-    TableAccess,
-};
 use crate::pool::PoolSettings;
 use crate::sharding::Sharder;

@@ -135,10 +129,6 @@ impl QueryRouter {
        self.pool_settings = pool_settings;
    }

-    pub fn pool_settings<'a>(&'a self) -> &'a PoolSettings {
-        &self.pool_settings
-    }
-
    /// Try to parse a command and execute it.
    pub fn try_execute_command(&mut self, message_buffer: &BytesMut) -> Option<(Command, String)> {
        let mut message_cursor = Cursor::new(message_buffer);
@@ -334,7 +324,10 @@ impl QueryRouter {
        Some((command, value))
    }

-    pub fn parse(message: &BytesMut) -> Result<Vec<sqlparser::ast::Statement>, Error> {
+    /// Try to infer which server to connect to based on the contents of the query.
+    pub fn infer(&mut self, message: &BytesMut) -> bool {
+        debug!("Inferring role");
+
        let mut message_cursor = Cursor::new(message);

        let code = message_cursor.get_u8() as char;
@@ -360,29 +353,28 @@ impl QueryRouter {
                query
            }

-            _ => return Err(Error::UnsupportedStatement),
+            _ => return false,
        };

-        match Parser::parse_sql(&PostgreSqlDialect {}, &query) {
-            Ok(ast) => Ok(ast),
+        let ast = match Parser::parse_sql(&PostgreSqlDialect {}, &query) {
+            Ok(ast) => ast,
            Err(err) => {
+                // SELECT ... FOR UPDATE won't get parsed correctly.
                debug!("{}: {}", err, query);
-                Err(Error::QueryRouterParserError(err.to_string()))
+                self.active_role = Some(Role::Primary);
+                return false;
            }
-        }
-    }
+        };

-    /// Try to infer which server to connect to based on the contents of the query.
-    pub fn infer(&mut self, ast: &Vec<sqlparser::ast::Statement>) -> Result<(), Error> {
-        debug!("Inferring role");
+        debug!("AST: {:?}", ast);

        if ast.is_empty() {
            // That's weird, no idea, let's go to primary
            self.active_role = Some(Role::Primary);
-            return Err(Error::QueryRouterParserError("empty query".into()));
+            return false;
        }

-        for q in ast {
+        for q in &ast {
            match q {
                // All transactions go to the primary, probably a write.
                StartTransaction { .. } => {
@@ -426,7 +418,7 @@ impl QueryRouter {
            };
        }

-        Ok(())
+        true
    }

    /// Parse the shard number from the Bind message
@@ -791,34 +783,6 @@ impl QueryRouter {
        }
    }

-    /// Add your plugins here and execute them.
-    pub async fn execute_plugins(&self, ast: &Vec<Statement>) -> Result<PluginOutput, Error> {
-        if query_logger::enabled() {
-            let mut query_logger = QueryLogger {};
-            let _ = query_logger.run(&self, ast).await;
-        }
-
-        if intercept::enabled() {
-            let mut intercept = Intercept {};
-            let result = intercept.run(&self, ast).await;
-
-            if let Ok(PluginOutput::Intercept(output)) = result {
-                return Ok(PluginOutput::Intercept(output));
-            }
-        }
-
-        if table_access::enabled() {
-            let mut table_access = TableAccess {};
-            let result = table_access.run(&self, ast).await;
-
-            if let Ok(PluginOutput::Deny(error)) = result {
-                return Ok(PluginOutput::Deny(error));
-            }
-        }
-
-        Ok(PluginOutput::Allow)
-    }
-
    fn set_sharding_key(&mut self, sharding_key: i64) -> Option<usize> {
        let sharder = Sharder::new(
            self.pool_settings.shards,
@@ -846,23 +810,12 @@ impl QueryRouter {
    /// Should we attempt to parse queries?
    pub fn query_parser_enabled(&self) -> bool {
        let enabled = match self.query_parser_enabled {
-            None => {
-                debug!(
-                    "Using pool settings, query_parser_enabled: {}",
-                    self.pool_settings.query_parser_enabled
-                );
-                self.pool_settings.query_parser_enabled
-            }
-
-            Some(value) => {
-                debug!(
-                    "Using query parser override, query_parser_enabled: {}",
-                    value
-                );
-                value
-            }
+            None => self.pool_settings.query_parser_enabled,
+            Some(value) => value,
        };

+        debug!("Query parser enabled: {}", enabled);
+
        enabled
    }

@@ -909,7 +862,7 @@ mod test {

        for query in queries {
            // It's a recognized query
-            assert!(qr.infer(&QueryRouter::parse(&query).unwrap()).is_ok());
+            assert!(qr.infer(&query));
            assert_eq!(qr.role(), Some(Role::Replica));
        }
    }
@@ -928,7 +881,7 @@ mod test {

        for query in queries {
            // It's a recognized query
-            assert!(qr.infer(&QueryRouter::parse(&query).unwrap()).is_ok());
+            assert!(qr.infer(&query));
            assert_eq!(qr.role(), Some(Role::Primary));
        }
    }
@@ -940,7 +893,7 @@ mod test {
        let query = simple_query("SELECT * FROM items WHERE id = 5");
        assert!(qr.try_execute_command(&simple_query("SET PRIMARY READS TO on")) != None);

-        assert!(qr.infer(&QueryRouter::parse(&query).unwrap()).is_ok());
+        assert!(qr.infer(&query));
        assert_eq!(qr.role(), None);
    }

@@ -960,7 +913,7 @@ mod test {
        res.put(prepared_stmt);
        res.put_i16(0);

-        assert!(qr.infer(&QueryRouter::parse(&res).unwrap()).is_ok());
+        assert!(qr.infer(&res));
        assert_eq!(qr.role(), Some(Role::Replica));
    }

@@ -1124,11 +1077,11 @@ mod test {
        assert_eq!(qr.role(), None);

        let query = simple_query("INSERT INTO test_table VALUES (1)");
-        assert!(qr.infer(&QueryRouter::parse(&query).unwrap()).is_ok());
+        assert!(qr.infer(&query));
        assert_eq!(qr.role(), Some(Role::Primary));

        let query = simple_query("SELECT * FROM test_table");
-        assert!(qr.infer(&QueryRouter::parse(&query).unwrap()).is_ok());
+        assert!(qr.infer(&query));
        assert_eq!(qr.role(), Some(Role::Replica));

        assert!(qr.query_parser_enabled());
@@ -1160,7 +1113,6 @@ mod test {
            auth_query: None,
            auth_query_password: None,
            auth_query_user: None,
-            db: "test".to_string(),
        };
        let mut qr = QueryRouter::new();
        assert_eq!(qr.active_role, None);
@@ -1190,24 +1142,15 @@ mod test {
        QueryRouter::setup();

        let mut qr = QueryRouter::new();
-        assert!(qr
-            .infer(&QueryRouter::parse(&simple_query("BEGIN; SELECT 1; COMMIT;")).unwrap())
-            .is_ok());
+        assert!(qr.infer(&simple_query("BEGIN; SELECT 1; COMMIT;")));
        assert_eq!(qr.role(), Role::Primary);

-        assert!(qr
-            .infer(&QueryRouter::parse(&simple_query("SELECT 1; SELECT 2;")).unwrap())
-            .is_ok());
+        assert!(qr.infer(&simple_query("SELECT 1; SELECT 2;")));
        assert_eq!(qr.role(), Role::Replica);

-        assert!(qr
-            .infer(
-                &QueryRouter::parse(&simple_query(
-                    "SELECT 123; INSERT INTO t VALUES (5); SELECT 1;"
-                ))
-                .unwrap()
-            )
-            .is_ok());
+        assert!(qr.infer(&simple_query(
+            "SELECT 123; INSERT INTO t VALUES (5); SELECT 1;"
+        )));
        assert_eq!(qr.role(), Role::Primary);
    }

@@ -1234,7 +1177,6 @@ mod test {
            auth_query: None,
            auth_query_password: None,
            auth_query_user: None,
-            db: "test".to_string(),
        };
        let mut qr = QueryRouter::new();
        qr.update_pool_settings(pool_settings.clone());
@@ -1266,84 +1208,47 @@ mod test {
        qr.pool_settings.automatic_sharding_key = Some("data.id".to_string());
        qr.pool_settings.shards = 3;

-        assert!(qr
-            .infer(&QueryRouter::parse(&simple_query("SELECT * FROM data WHERE id = 5")).unwrap())
-            .is_ok());
+        assert!(qr.infer(&simple_query("SELECT * FROM data WHERE id = 5")));
        assert_eq!(qr.shard(), 2);

-        assert!(qr
-            .infer(
-                &QueryRouter::parse(&simple_query(
-                    "SELECT one, two, three FROM public.data WHERE id = 6"
-                ))
-                .unwrap()
-            )
-            .is_ok());
+        assert!(qr.infer(&simple_query(
+            "SELECT one, two, three FROM public.data WHERE id = 6"
+        )));
        assert_eq!(qr.shard(), 0);

-        assert!(qr
-            .infer(
-                &QueryRouter::parse(&simple_query(
-                    "SELECT * FROM data
+        assert!(qr.infer(&simple_query(
+            "SELECT * FROM data
            INNER JOIN t2 ON data.id = 5
            AND t2.data_id = data.id
        WHERE data.id = 5"
-                ))
-                .unwrap()
-            )
-            .is_ok());
+        )));
        assert_eq!(qr.shard(), 2);

        // Shard did not move because we couldn't determine the sharding key since it could be ambiguous
        // in the query.
-        assert!(qr
-            .infer(
-                &QueryRouter::parse(&simple_query(
-                    "SELECT * FROM t2 INNER JOIN data ON id = 6 AND data.id = t2.data_id"
-                ))
-                .unwrap()
-            )
-            .is_ok());
+        assert!(qr.infer(&simple_query(
+            "SELECT * FROM t2 INNER JOIN data ON id = 6 AND data.id = t2.data_id"
+        )));
        assert_eq!(qr.shard(), 2);

-        assert!(qr
-            .infer(
-                &QueryRouter::parse(&simple_query(
-                    r#"SELECT * FROM "public"."data" WHERE "id" = 6"#
-                ))
-                .unwrap()
-            )
-            .is_ok());
+        assert!(qr.infer(&simple_query(
+            r#"SELECT * FROM "public"."data" WHERE "id" = 6"#
+        )));
        assert_eq!(qr.shard(), 0);

-        assert!(qr
-            .infer(
-                &QueryRouter::parse(&simple_query(
-                    r#"SELECT * FROM "public"."data" WHERE "data"."id" = 5"#
-                ))
-                .unwrap()
-            )
-            .is_ok());
+        assert!(qr.infer(&simple_query(
+            r#"SELECT * FROM "public"."data" WHERE "data"."id" = 5"#
+        )));
        assert_eq!(qr.shard(), 2);

        // Super unique sharding key
        qr.pool_settings.automatic_sharding_key = Some("*.unique_enough_column_name".to_string());
-        assert!(qr
-            .infer(
-                &QueryRouter::parse(&simple_query(
-                    "SELECT * FROM table_x WHERE unique_enough_column_name = 6"
-                ))
-                .unwrap()
-            )
-            .is_ok());
+        assert!(qr.infer(&simple_query(
+            "SELECT * FROM table_x WHERE unique_enough_column_name = 6"
+        )));
        assert_eq!(qr.shard(), 0);

-        assert!(qr
-            .infer(
-                &QueryRouter::parse(&simple_query("SELECT * FROM table_y WHERE another_key = 5"))
-                    .unwrap()
-            )
-            .is_ok());
+        assert!(qr.infer(&simple_query("SELECT * FROM table_y WHERE another_key = 5")));
        assert_eq!(qr.shard(), 0);
    }

@@ -1367,40 +1272,11 @@ mod test {
        qr.pool_settings.automatic_sharding_key = Some("data.id".to_string());
        qr.pool_settings.shards = 3;

-        assert!(qr
-            .infer(&QueryRouter::parse(&simple_query(stmt)).unwrap())
-            .is_ok());
+        assert!(qr.infer(&simple_query(stmt)));
        assert_eq!(qr.placeholders.len(), 1);

        assert!(qr.infer_shard_from_bind(&bind));
        assert_eq!(qr.shard(), 2);
        assert!(qr.placeholders.is_empty());
    }
-
-    #[tokio::test]
-    async fn test_table_access_plugin() {
-        use crate::config::TableAccess;
-        let ta = TableAccess {
-            enabled: true,
-            tables: vec![String::from("pg_database")],
-        };
-
-        crate::plugins::table_access::setup(&ta);
-
-        QueryRouter::setup();
-
-        let qr = QueryRouter::new();
-
-        let query = simple_query("SELECT * FROM pg_database");
-        let ast = QueryRouter::parse(&query).unwrap();
-
-        let res = qr.execute_plugins(&ast).await;
-
-        assert_eq!(
-            res,
-            Ok(PluginOutput::Deny(
-                "permission for table \"pg_database\" denied".to_string()
-            ))
-        );
-    }
 }
--- a/src/server.rs
+++ b/src/server.rs
@@ -7,7 +7,6 @@ use parking_lot::{Mutex, RwLock};
 use postgres_protocol::message;
 use std::collections::HashMap;
 use std::io::Read;
-use std::net::IpAddr;
 use std::sync::Arc;
 use std::time::SystemTime;
 use tokio::io::{AsyncRead, AsyncReadExt, AsyncWrite, BufStream};
@@ -17,7 +16,6 @@ use tokio_rustls::{client::TlsStream, TlsConnector};

 use crate::config::{get_config, Address, User};
 use crate::constants::*;
-use crate::dns_cache::{AddrSet, CACHED_RESOLVER};
 use crate::errors::{Error, ServerIdentifier};
 use crate::messages::*;
 use crate::mirrors::MirroringManager;
@@ -150,9 +148,6 @@ pub struct Server {
    last_activity: SystemTime,

    mirror_manager: Option<MirroringManager>,
-
-    // Associated addresses used
-    addr_set: Option<AddrSet>,
 }

 impl Server {
@@ -166,24 +161,6 @@ impl Server {
        stats: Arc<ServerStats>,
        auth_hash: Arc<RwLock<Option<String>>>,
    ) -> Result<Server, Error> {
-        let cached_resolver = CACHED_RESOLVER.load();
-        let mut addr_set: Option<AddrSet> = None;
-
-        // If we are caching addresses and hostname is not an IP
-        if cached_resolver.enabled() && address.host.parse::<IpAddr>().is_err() {
-            debug!("Resolving {}", &address.host);
-            addr_set = match cached_resolver.lookup_ip(&address.host).await {
-                Ok(ok) => {
-                    debug!("Obtained: {:?}", ok);
-                    Some(ok)
-                }
-                Err(err) => {
-                    warn!("Error trying to resolve {}, ({:?})", &address.host, err);
-                    None
-                }
-            }
-        };
-
        let mut stream =
            match TcpStream::connect(&format!("{}:{}", &address.host, address.port)).await {
                Ok(stream) => stream,
@@ -632,7 +609,6 @@ impl Server {
                        bad: false,
                        needs_cleanup: false,
                        client_server_map,
-                        addr_set,
                        connected_at: chrono::offset::Utc::now().naive_utc(),
                        stats,
                        application_name: String::new(),
@@ -873,23 +849,7 @@ impl Server {
    /// Server & client are out of sync, we must discard this connection.
    /// This happens with clients that misbehave.
    pub fn is_bad(&self) -> bool {
-        if self.bad {
-            return self.bad;
-        };
-        let cached_resolver = CACHED_RESOLVER.load();
-        if cached_resolver.enabled() {
-            if let Some(addr_set) = &self.addr_set {
-                if cached_resolver.has_changed(self.address.host.as_str(), addr_set) {
-                    warn!(
-                        "DNS changed for {}, it was {:?}. Dropping server connection.",
-                        self.address.host.as_str(),
-                        addr_set
-                    );
-                    return true;
-                }
-            }
-        }
-        false
+        self.bad
    }

    /// Get server startup information to forward it to the client.
--- a/tests/ruby/admin_spec.rb
+++ b/tests/ruby/admin_spec.rb
@@ -71,17 +71,15 @@ describe "Admin" do

    context "client connects but issues no queries" do
      it "only affects cl_idle stats" do
-        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
-
-        before_test = admin_conn.async_exec("SHOW POOLS")[0]["sv_idle"]
        connections = Array.new(20) { PG::connect(pgcat_conn_str) }
        sleep(1)
+        admin_conn = PG::connect(processes.pgcat.admin_connection_string)
        results = admin_conn.async_exec("SHOW POOLS")[0]
        %w[cl_active cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
        end
        expect(results["cl_idle"]).to eq("20")
-        expect(results["sv_idle"]).to eq(before_test)
+        expect(results["sv_idle"]).to eq("1")

        connections.map(&:close)
        sleep(1.1)
@@ -89,7 +87,7 @@ describe "Admin" do
        %w[cl_active cl_idle cl_waiting cl_cancel_req sv_active sv_used sv_tested sv_login maxwait].each do |s|
          raise StandardError, "Field #{s} was expected to be 0 but found to be #{results[s]}" if results[s] != "0"
        end
-        expect(results["sv_idle"]).to eq(before_test)
+        expect(results["sv_idle"]).to eq("1")
      end
    end

--- a/tests/ruby/plugins_spec.rb
+++ b/tests/ruby/plugins_spec.rb
@@ -1,14 +0,0 @@
-require_relative 'spec_helper'
-
-
-describe "Plugins" do
-  let(:processes) { Helpers::Pgcat.three_shard_setup("sharded_db", 5) }
-
-  context "intercept" do
-    it "will intercept an intellij query" do
-      conn = PG.connect(processes.pgcat.connection_string("sharded_db", "sharding_user"))
-      res = conn.exec("select current_database() as a, current_schemas(false) as b")
-      expect(res.values).to eq([["sharded_db", "{public}"]])
-    end
-  end
-end
Author	SHA1	Message	Date
Lev Kokotov	ee23b374ae	fetch config once	2023-04-30 09:19:39 -07:00
Lev Kokotov	9dffebccbf	remove unused error	2023-04-30 09:07:15 -07:00
Lev Kokotov	4c8358b8b3	skip flakey test	2023-04-30 09:03:32 -07:00
Lev Kokotov	f0d1916a98	dirty shutdown	2023-04-30 08:23:30 -07:00
Lev Kokotov	bba5f10be1	maybe?	2023-04-29 08:38:27 -07:00
Lev Kokotov	a514dbc187	remove dead code	2023-04-28 18:08:20 -07:00
Lev Kokotov	d660e3e565	diff	2023-04-28 18:06:11 -07:00
Lev Kokotov	0d882cc204	thats it	2023-04-28 18:05:28 -07:00
Lev Kokotov	b36746a47b	Finish up TLS	2023-04-28 18:02:48 -07:00
Lev Kokotov	9e51b8110f	Server TLS	2023-04-28 11:20:49 -07:00