小叙：为啥要用 Rust + PostgreSQL 搞起个项目？

说实话，hen多人一听到 Rust 就想到“高性Neng、内存安全”，但往往又怕上手慢。

再kankan PostgreSQL，老牌数据库，特性满满，连全文搜索、物化视图dou有。

把两者扯在一起，你会发现：写代码快、运行稳、运维省。

哈哈，这不就是我们独立开发者的理想组合嘛！

第一步：准备工作，别装逼直接跑

先装好 Rust 开发工具链，rustup update，别忘了加上 nightly。

再把 Postgres 安装好，启动服务。

然后在项目根目录新建 .env，写上数据库连接：

DATABASE_URL=postgres://postgres:yourpassword@localhost:5432/rust_demo

别担心密码泄露，这里只演示，实际部署请用 secret 管理。

创建 Cargo 项目

cargo new rust-postgres-demo
cd rust-postgres-demo

添加依赖

tokio = { version = "1", features =  }
sqlx = { version = "0.7", features =  }
axum = "0.6"
serde = { version = "1", features =  }
serde_json = "1"
dotenvy = "0.15"
uuid = { version = "1", features =  }
chrono = { version = "0.4", features =  }

第二步：数据库模型设计——一次搞定缓存+搜索+队列

咱们不想再去装 Redis、Elastic 那套中间件，对吧？直接用 Postgres 的特性把它们“吃掉”。

用户表 + 物化视图

CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
CREATE TABLE IF NOT EXISTS users (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4,
    username VARCHAR NOT NULL UNIQUE,
    email VARCHAR NOT NULL UNIQUE,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW,
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW
);
-- 复杂查询结果直接存成物化视图
CREATE MATERIALIZED VIEW IF NOT EXISTS mv_user_list AS
SELECT id, username, email
FROM users
ORDER BY created_at DESC;
CREATE INDEX IF NOT EXISTS idx_mv_user_list_id ON mv_user_list;

说白了这玩意儿就是把热点查询提前算好，一查就命中磁盘缓存，省得每次dou扫表。

文章表 + 全文搜索向量

CREATE EXTENSION IF NOT EXISTS pg_trgm;   -- 支持模糊匹配
CREATE TABLE IF NOT EXISTS articles (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4,
    title VARCHAR NOT NULL,
    content TEXT NOT NULL,
    author_id UUID REFERENCES users,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW,
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW,
    search_vector tsvector GENERATED ALWAYS AS (
        to_tsvector
    ) STORED
);
CREATE INDEX IF NOT EXISTS idx_articles_search ON articles USING GIN;
CREATE INDEX IF NOT EXISTS idx_articles_trgm ON articles USING GIST ;

这样一来只要写 WHERE search_vector @@ plainto_tsquery 就Neng实现关键词搜索。中文的话装个 jieba 就行啦。

消息队列表

CREATE TABLE IF NOT EXISTS message_queue (
    id UUID PRIMARY KEY DEFAULT uuid_generate_v4,
    queue_name VARCHAR NOT NULL,
    payload JSONB NOT NULL,
    status VARCHAR NOT NULL DEFAULT 'pending',
    retry_count INT NOT NULL DEFAULT 0,
    created_at TIMESTAMPTZ NOT NULL DEFAULT NOW,
    updated_at TIMESTAMPTZ NOT NULL DEFAULT NOW
);
CREATE INDEX IF NOT EXISTS idx_queue_name_status ON message_queue;

配合 SLECT ... FOR UPDATE SKIP LOCKED 和 pg_notify, 完全Ke以实现可靠的异步消费。

第三步：写点代码，让它们活起来——Axum + SQLx 实战示例 初始化全局状态

use sqlx::postgres::PgPoolOptions;
use std::sync::Arc;
use tokio::time::Duration;
#
struct AppState {
    pool: Arc,
}
async fn init_state -> AppState {
    let db_url =
        std::env::var.expect;
    let pool = PgPoolOptions::new
        .max_connections
        .min_connections
        .acquire_timeout)
        .idle_timeout)
        .connect
        .await
        .expect;
    AppState { pool: Arc::new }
}

API：获取用户列表

use axum::{Router, routing::get, Json, extract::State};
use serde::Serialize;
#
struct UserDto {
    id: uuid::Uuid,
    username: String,
    email: String,
}
async fn list_users: State) -> Json {
    let rows = sqlx::query_as!(
        UserDto,
        r#"SELECT id as "id!", username as "username!", email as "email!" 
           FROM mv_user_list LIMIT 100"# // 随便限制一下
     )
     .fetch_all
     .await
     .unwrap;
    Json
}

API：全文搜索文章

use serde::{Deserialize, Serialize};
#
struct SearchReq {
    keyword: String,
    page: u32,
}
#
struct ArticleDto {
    id: uuid::Uuid,
    title: String,
    snippet: String,
}
async fn search_articles(
   State: State,
   Json: Json,
) -> Json {
   let offset =  * 10) as i64;
   let pattern = format!; // 前缀匹配
   let rows = sqlx::query_as!(
       ArticleDto,
       r#"
       SELECT id, title,
              left as snippet
       FROM articles
       WHERE search_vector @@ to_tsquery
       ORDER BY ts_rank) DESC
       LIMIT 10 OFFSET $2
       "#,
       pattern,
       offset
   )
   .fetch_all
   .await
   .unwrap;
   Json
}

生产者：往队列塞消息并通知消费者

use axum::{Json, extract::State};
use serde_json::Value;
#
struct SendMsgReq {
   queue_name: String,
   payload: Value,
}
async fn send_message(
   State: State,
   Json: Json,
) -> Json {
   // 插入消息记录
   let rec = sqlx::query!(
       r#"INSERT INTO message_queue 
          VALUES  RETURNING id"#,
       req.queue_name,&req.payload
   )
   .fetch_one
   .await
   .unwrap;
   // 用 pg_notify 推送通知，让消费者马上醒来
   sqlx::query!", req.queue_name, rec.id.to_string)
      .execute
      .await
      .unwrap;
   Json
}

消费者：使用 PgListener 实时消费并处理业务事务

use sqlx::{PgListener, Transaction};
use std::{time::Duration};
async fn start_consumer {
   let mut listener =
      PgListener::connect_with.await.unwrap;
   listener.listen.await.unwrap;
   println!;
   loop {
      match listener.recv.await {
         Ok => {
            let msg_id = notif.payload.parse::.unwrap;
            // 开事务避免脏读，用 SKIP LOCKED 防止竞争
            let mut tx: Transaction<'_, _>= state.pool.begin.await.unwrap;
            if let Some=sqlx::query_as!(
               MessageRecord,
               r#"
               SELECT id,payload FROM message_queue 
               WHERE id=$1 AND status='pending'
               FOR UPDATE SKIP LOCKED
               "#, msg_id
            ).fetch_optional.await.unwrap {
                // 假设这里是业务处理，比如发邮件、geng新统计等...
                println!;
                // 标记完成
                sqlx::query!
                    .execute.await.unwrap;
            }
            tx.commit.await.unwrap;
         },
         Err => {
            eprintln!;
            tokio::time::sleep).await;
         },
      }
   }
}
struct MessageRecord { id: uuid::Uuid, payload: serde_json::Value }

第四步：运维小技巧——让 Postgres geng像“万Neng中间件”

* 缓存预热：

sqlx::query!")
      .execute.await.unwrap;

* 定时刷新物化视图，用 cron 或 systemd timer dou行：

# 每小时刷新一次缓存视图
0 * * * * psql $DATABASE_URL -c "REFRESH MATERIALIZED VIEW CONCURRENTLY mv_user_list;"

* 想要分布式锁？PostgreSQL 的 advisory lock Neng帮忙：

SELECT pgadvisorylock; -- 加锁
-- Zuo业务
SELECT pgadvisoryunlock; -- 解锁

收尾感悟：别忘了“适合自己才是王道”

说实话，这套栈不是万Neng钥匙。

If you need ultra‑low latency cache at million QPS level，那 Redis 还是geng合适；Ru果你要海量日志分析，那 Elastic/ClickHouse 才是正选。

Ciao~ 咱就是说对于大多数中小项目，用 Rust 写业务层，用 PostgreSQL 把缓存、搜索、队列dou“一锅炖”，省钱、省心，还Neng享受编译时安全检查带来的安心感。

Zui后提醒一下：

- 保持依赖Zui新；

- 给关键表加上合适的索引；

- 定期监控 pg_stat_activity 防止长事务卡库；

- 多利用 ，不要硬逼自己写轮子。

# # # 好了就酱。祝你玩得开心，代码跑得飞快！哈哈 🤘

---