In this guide we’re going to look at what exactly diesel print-schema and table! do. For table!, we will show a simplified version of the actual code that gets generated, and explain how each piece is relevant to you. If you’ve ever been confused about what exactly is getting generated, or what use schema::posts::dsl::* means, this is the right place to be.

    diesel print-schema is a command provided by Diesel CLI. This command will establish a database connection, query for a list of all the tables and their columns, and generate table! invocations for each one. diesel print-schema will skip any table names which start with __ (a double underscore). Diesel can be configured to automatically re-run diesel print-schema whenever you run migrations. See Configuring Diesel CLI for details.

    table! is where the bulk of the code gets generated. If you wanted to, you could see the actual exact code that gets generated by running cargo rustc -- -Z unstable-options --pretty=expanded. However, the output will be quite noisy, and there’s a lot of code that won’t actually be relevant to you. Instead we’re going to go step by step through a simplified version of this output, which only has the code which you would use directly.

    For this example, we’ll look at the code generated by this table! invocation:

    1. table! {
    2.     users {
    3.         id -> Integer,
    4.         name -> Text,
    5.         hair_color -> Nullable<Text>,
    6.     }
    7. }

    If you just want to see the full simplified code and look through it yourself, you will find it at the end of this guide.

    The output of table! is always a Rust module with the same name. The first and most important part of this module will be the definition of the table itself:

    1. pub struct table;

    This is the struct that represents the user’s table for the purpose of constructing SQL queries. It’s usually referenced in code as users::table (or sometimes just users, more on that in a bit). Next, we’ll see there’s a module called columns, with one struct per column of the table.

    1. pub struct id;
    2. pub struct name;
    3. pub struct hair_color;

    Each of these structs uniquely represents each column of the table for the purpose of constructing SQL queries. Each of these structs will implement a trait called Expression, which indicates the SQL type of the column.

    1. impl Expression for id {
    2.     type SqlType = Integer;
    3. }
    5. impl Expression for name {
    6.     type SqlType = Text;
    7. }
    9. impl Expression for hair_color {
    10.     type SqlType = Nullable<Text>;
    11. }

    The SqlType type is at the core of how Diesel ensures that your queries are correct. This type will be used by ExpressionMethods to determine what things can and cannot be passed to methods like eq. It will also be used by Queryable to determine what types can be deserialized when this column appears in the select clause.

    In the columns module you’ll also see a special column called star. Its definition looks like this:

    1. pub struct star;
    3. impl Expression for star {
    4.     type SqlType = ();
    5. }

    The star struct represents users.* in the query builder. This struct is only intended to be used for generating count queries. It should never be used directly. Diesel loads your data from a query by index, not by name. In order to ensure that we’re actually getting the data for the column we think we are, Diesel never uses * when we actually want to get the data back out of it. We will instead generate an explicit select clause such as SELECT users.id, users.name, users.hair_color.

    Everything in the columns module will be re-exported from the parent module. This is why we can reference columns as users::id, and not users::columns::id.

    1. pub use self::columns::*;
    3. pub struct table;
    5. pub mod columns {
    6.     /* ... */
    7. }

    Queries can often get quite verbose when everything has to be prefixed with users::. For this reason, Diesel also provides a convenience module called dsl.

    1. pub mod dsl {
    2.     pub use super::columns::{id, name, hair_color};
    3.     pub use super::table as users;
    4. }

    This module re-exports everything in columns module (except for star), and also re-exports the table but renamed to the actual name of the table. This means that instead of writing

    1. users::table
    2.   .filter(users::name.eq("Sean"))
    3.   .filter(users::hair_color.eq("black"))

    we can instead write

    1. users.filter(name.eq("Sean")).filter(hair_color.eq("black"))

    The dsl module should only ever be imported for single functions. You should never have use schema::users::dsl::*; at the top of a module. Code like #[derive(Insertable)] will assume that users points to the module, not the table struct.

    Since star is otherwise inaccessible if you have use schema::users::dsl::*;, it is also exposed as an instance method on the table.

    1. impl table {
    2.     pub fn star(&self) -> star {
    3.         star
    4.     }
    5. }

    Next, there are several traits that get implemented for table. You generally will never interact with these directly, but they are what enable most of the query builder functions found in the query_dsl module, as well as use with insert, update, and delete.

    1. impl AsQuery for table {
    2.     /* body omitted */
    3. }
    5. impl Table for table {
    6.     /* body omitted */
    7. }
    9. impl IntoUpdateTarget for table {
    10.     /* body omitted */
    11. }

    Finally, there are a few small type definitions and constants defined to make your life easier.

    1. pub const all_columns: (id, name, hair_color) = (id, name, hair_color);
    3. pub type SqlType = (Integer, Text, Nullable<Text>);
    5. pub type BoxedQuery<'a, DB, ST = SqlType> = BoxedSelectStatement<'a, ST, table, DB>;

    all_columns is just a tuple of all of the column on the table. It is what is used to generate the select statement for a query on this table when you don’t specify one explicitly. If you ever want to reference users::star for things that aren’t count queries, you probably want users::all_columns instead.

    SqlType will be the SQL type of all_columns. It’s rare to need to reference this directly, but it’s less verbose than <<users::table as Table>::AllColumns as Expression>::SqlType when you need it.

    Finally, there is a helper type for referencing boxed queries built from this table. This means that instead of writing BoxedSelectStatement<'static, users::SqlType, users::table, Pg> you can instead write users::BoxedQuery<'static, Pg>. You can optionally specify the SQL type as well if the query has a custom select clause.

    And that’s everything! Here is the full code that was generated for this table:

    1. pub mod users {
    2.     pub use self::columns::*;
    4.     pub mod dsl {
    5.         pub use super::columns::{id, name, hair_color};
    6.         pub use super::table as users;
    7.     }
    9.     pub const all_columns: (id, name, hair_color) = (id, name, hair_color);
    11.     pub struct table;
    13.     impl table {
    14.         pub fn star(&self) -> star {
    15.             star
    16.         }
    17.     }
    19.     pub type SqlType = (Integer, Text, Nullable<Text>);
    21.     pub type BoxedQuery<'a, DB, ST = SqlType> = BoxedSelectStatement<'a, ST, table, DB>;
    23.     impl AsQuery for table {
    24.         /* body omitted */
    25.     }
    27.     impl Table for table {
    28.         /* body omitted */
    29.     }
    31.     impl IntoUpdateTarget for table {
    32.         /* body omitted */
    33.     }
    35.     pub mod columns {
    36.         pub struct star;
    38.         impl Expression for star {
    39.             type SqlType = ();
    40.         }
    42.         pub struct id;
    44.         impl Expression for id {
    45.             type SqlType = Integer;
    46.         }
    48.         pub struct name;
    50.         impl Expression for name {
    51.             type SqlType = Text;
    52.         }
    54.         pub struct hair_color;
    56.         impl Expression for hair_color {
    57.             type SqlType = Nullable<Text>;
    58.         }
    59.     }
    60. }