sea_query/backend/
index_builder.rs

1use crate::*;
2
3pub trait IndexBuilder: QuotedBuilder + TableRefBuilder {
4    /// Translate [`IndexCreateStatement`] into SQL expression.
5    /// This is the default implementation for `PostgresQueryBuilder` and `SqliteQueryBuilder`.
6    /// `MysqlQueryBuilder` overrides this default implementation.
7    fn prepare_table_index_expression(
8        &self,
9        create: &IndexCreateStatement,
10        sql: &mut dyn SqlWriter,
11    ) {
12        if let Some(name) = &create.index.name {
13            write!(
14                sql,
15                "CONSTRAINT {}{}{} ",
16                self.quote().left(),
17                name,
18                self.quote().right()
19            )
20            .unwrap();
21        }
22
23        self.prepare_index_prefix(create, sql);
24
25        self.prepare_index_columns(&create.index.columns, sql);
26
27        self.prepare_filter(&create.r#where, sql);
28    }
29
30    /// Translate [`IndexCreateStatement`] into SQL statement.
31    fn prepare_index_create_statement(
32        &self,
33        create: &IndexCreateStatement,
34        sql: &mut dyn SqlWriter,
35    );
36
37    /// Translate [`TableRef`] into SQL statement.
38    fn prepare_table_ref_index_stmt(&self, table_ref: &TableRef, sql: &mut dyn SqlWriter);
39
40    /// Translate [`IndexDropStatement`] into SQL statement.
41    fn prepare_index_drop_statement(&self, drop: &IndexDropStatement, sql: &mut dyn SqlWriter);
42
43    #[doc(hidden)]
44    /// Write the index type (Btree, hash, ...).
45    fn prepare_index_type(&self, _col_index_type: &Option<IndexType>, _sql: &mut dyn SqlWriter) {}
46
47    #[doc(hidden)]
48    /// Write the index prefix (primary, unique, ...).
49    fn prepare_index_prefix(&self, create: &IndexCreateStatement, sql: &mut dyn SqlWriter);
50
51    #[doc(hidden)]
52    /// Write the column index prefix.
53    fn write_column_index_prefix(&self, col_prefix: &Option<u32>, sql: &mut dyn SqlWriter) {
54        if let Some(prefix) = col_prefix {
55            write!(sql, " ({prefix})").unwrap();
56        }
57    }
58
59    #[doc(hidden)]
60    /// Write the index column with table column.
61    fn prepare_index_column_with_table_column(
62        &self,
63        column: &IndexColumnTableColumn,
64        sql: &mut dyn SqlWriter,
65    ) {
66        column.name.prepare(sql.as_writer(), self.quote());
67        self.write_column_index_prefix(&column.prefix, sql);
68        if let Some(order) = &column.order {
69            match order {
70                IndexOrder::Asc => write!(sql, " ASC").unwrap(),
71                IndexOrder::Desc => write!(sql, " DESC").unwrap(),
72            }
73        }
74    }
75
76    #[doc(hidden)]
77    /// Write the column index prefix.
78    fn prepare_index_columns(&self, columns: &[IndexColumn], sql: &mut dyn SqlWriter) {
79        write!(sql, "(").unwrap();
80        columns.iter().fold(true, |first, col| {
81            if !first {
82                write!(sql, ", ").unwrap();
83            }
84            match col {
85                IndexColumn::TableColumn(column) => {
86                    self.prepare_index_column_with_table_column(column, sql);
87                }
88                IndexColumn::Expr(_) => panic!("Not supported"),
89            }
90            false
91        });
92        write!(sql, ")").unwrap();
93    }
94
95    #[doc(hidden)]
96    // Write WHERE clause for partial index. This function is not available in MySQL.
97    fn prepare_filter(&self, _condition: &ConditionHolder, _sql: &mut dyn SqlWriter) {}
98}