#[derive(Serialize)] for Record

Cargo.toml

@@ -12,6 +12,7 @@ members = [
     "examples/postgres/listen",
     "examples/postgres/todos",
     "examples/postgres/mockable-todos",
+    "examples/postgres/serialize",
     "examples/sqlite/todos",
 ]
 
@@ -92,6 +93,7 @@ time = [ "sqlx-core/time", "sqlx-macros/time" ]
 bit-vec = [ "sqlx-core/bit-vec", "sqlx-macros/bit-vec"]
 bstr = [ "sqlx-core/bstr" ]
 git2 = [ "sqlx-core/git2" ]
+serialize = [ "sqlx-core/serialize", "sqlx-macros/serialize" ]
 
 [dependencies]
 sqlx-core = { version = "0.5.1", path = "sqlx-core", default-features = false }

examples/postgres/serialize/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "serialize"
+version = "0.1.0"
+edition = "2018"
+workspace = "../../../"
+
+[dependencies]
+anyhow = "1.0"
+async-std = { version = "1.6.0", features = [ "attributes" ] }
+dotenv = "0.15.0"
+futures = "0.3"
+paw = "1.0"
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+sqlx = { path = "../../../", features = ["runtime-async-std-rustls", "postgres", "json", "serialize"] }
+structopt = { version = "0.3", features = ["paw"] }

examples/postgres/serialize/README.md

@@ -0,0 +1,47 @@
+# JSON Example using serialize feature
+
+When the serialize feature is enabled, the query!() macro returns a
+struct that implements serde::Serialize.  This means that each 'Row'
+value can be converted to json text using serde_json::to_string(&row).
+This includes nested 'jsonb', such as the person column in this
+example.
+
+## Setup
+
+1. Declare the database URL
+
+    ```
+    export DATABASE_URL="postgres://postgres:password@localhost/serialize"
+    ```
+
+2. Create the database.
+
+    ```
+    $ sqlx db create
+    ```
+
+3. Run sql migrations
+
+    ```
+    $ sqlx migrate run
+    ```
+
+## Usage
+
+Add a person
+
+```
+echo '{ "name": "John Doe", "age": 30 }' | cargo run -- add
+```
+
+or with extra keys
+
+```
+echo '{ "name": "Jane Doe", "age": 25, "array": ["string", true, 0] }' | cargo run -- add
+```
+
+List all people
+
+```
+cargo run
+```

examples/postgres/serialize/migrations/20200824190010_json.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS people
+(
+    id     BIGSERIAL PRIMARY KEY,
+    person JSONB NOT NULL
+);

examples/postgres/serialize/src/main.rs

@@ -0,0 +1,91 @@
+use serde::{Deserialize, Serialize};
+use serde_json::{Map, Value};
+use sqlx::postgres::PgPool;
+use sqlx::types::Json;
+use std::io::{self, Read};
+use std::num::NonZeroU8;
+use structopt::StructOpt;
+
+#[derive(StructOpt)]
+struct Args {
+    #[structopt(subcommand)]
+    cmd: Option<Command>,
+}
+
+#[derive(StructOpt)]
+enum Command {
+    Add,
+}
+
+#[derive(Deserialize, Serialize)]
+struct Person {
+    name: String,
+    age: NonZeroU8,
+    #[serde(flatten)]
+    extra: Map<String, Value>,
+}
+
+#[async_std::main]
+#[paw::main]
+async fn main(args: Args) -> anyhow::Result<()> {
+    let pool = PgPool::connect(&dotenv::var("DATABASE_URL")?).await?;
+
+    match args.cmd {
+        Some(Command::Add) => {
+            let mut json = String::new();
+            io::stdin().read_to_string(&mut json)?;
+
+            let person: Person = serde_json::from_str(&json)?;
+            println!(
+                "Adding new person: {}",
+                &serde_json::to_string_pretty(&person)?
+            );
+
+            let person_id = add_person(&pool, person).await?;
+            println!("Added new person with ID {}", person_id);
+        }
+        None => {
+            println!("{}", list_people(&pool).await?);
+        }
+    }
+
+    Ok(())
+}
+
+async fn add_person(pool: &PgPool, person: Person) -> anyhow::Result<i64> {
+    let rec = sqlx::query!(
+        r#"
+INSERT INTO people ( person )
+VALUES ( $1 )
+RETURNING id
+        "#,
+        Json(person) as _
+    )
+    .fetch_one(pool)
+    .await?;
+
+    Ok(rec.id)
+}
+
+async fn list_people(pool: &PgPool) -> anyhow::Result<String> {
+    let mut buf = String::from("[");
+    for (i, row) in sqlx::query!(
+        r#"
+SELECT id, person
+FROM people
+ORDER BY id
+        "#
+    )
+    .fetch_all(pool)
+    .await?
+    .iter()
+    .enumerate()
+    {
+        if i > 0 {
+            buf.push_str(",\n");
+        }
+        buf.push_str(&serde_json::to_string_pretty(&row)?);
+    }
+    buf.push_str("]\n");
+    Ok(buf)
+}

sqlx-core/Cargo.toml

@@ -32,6 +32,7 @@ all-types = [ "chrono", "time", "bigdecimal", "decimal", "ipnetwork", "json", "u
 bigdecimal = [ "bigdecimal_", "num-bigint" ]
 decimal = [ "rust_decimal", "num-bigint" ]
 json = [ "serde", "serde_json" ]
+serialize = [ "serde", "serde_json" ]
 
 # runtimes
 runtime-actix-native-tls = [ "sqlx-rt/runtime-actix-native-tls", "_tls-native-tls", "_rt-actix" ]

sqlx-macros/Cargo.toml

@@ -51,6 +51,7 @@ ipnetwork = [ "sqlx-core/ipnetwork" ]
 uuid = [ "sqlx-core/uuid" ]
 bit-vec = [ "sqlx-core/bit-vec" ]
 json = [ "sqlx-core/json", "serde_json" ]
+serialize = [ "serde", "serde_json" ]
 
 [dependencies]
 dotenv = { version = "0.15.0", default-features = false }

sqlx-macros/src/query/mod.rs

@@ -278,12 +278,19 @@ where
                      }| quote!(#ident: #type_,),
                 );
 
-                let mut record_tokens = quote! {
+                let mut record_tokens = TokenStream::new();
+
+                #[cfg(feature = "serialize")]
+                record_tokens.extend(quote! {
+                    #[derive(serde::Serialize)]
+                });
+
+                record_tokens.extend(quote! {
                     #[derive(Debug)]
                     struct #record_name {
                         #(#record_fields)*
                     }
-                };
+                });
 
                 record_tokens.extend(output::quote_query_as::<DB>(
                     &input,

tests/postgres/postgres.rs

@@ -887,3 +887,14 @@ from (values (null)) vals(val)
 
     Ok(())
 }
+
+#[cfg(feature = "serialize")]
+#[sqlx_macros::test]
+async fn it_row_serializes_to_json() -> anyhow::Result<()> {
+    let mut conn = new::<Postgres>().await?;
+
+    let json = serde_json::to_string(&sqlx::query!(" select (1) as id ").fetch_all(&pool).await?)?;
+    assert_eq!(&json, r#"[{"id":1}]"#);
+
+    Ok(())
+}