sea_query/backend/mysql/
index.rs

1use super::*;
2
3impl IndexBuilder for MysqlQueryBuilder {
4    fn prepare_table_index_expression(
5        &self,
6        create: &IndexCreateStatement,
7        sql: &mut dyn SqlWriter,
8    ) {
9        self.prepare_index_prefix(create, sql);
10        write!(sql, "KEY ").unwrap();
11
12        if let Some(name) = &create.index.name {
13            write!(
14                sql,
15                "{}{}{} ",
16                self.quote().left(),
17                name,
18                self.quote().right()
19            )
20            .unwrap();
21        }
22
23        self.prepare_index_type(&create.index_type, sql);
24        if matches!(create.index_type, Some(IndexType::FullText)) {
25            write!(sql, " ").unwrap();
26        }
27
28        self.prepare_index_columns(&create.index.columns, sql);
29    }
30
31    fn prepare_index_create_statement(
32        &self,
33        create: &IndexCreateStatement,
34        sql: &mut dyn SqlWriter,
35    ) {
36        write!(sql, "CREATE ").unwrap();
37        self.prepare_index_prefix(create, sql);
38        write!(sql, "INDEX ").unwrap();
39
40        if let Some(name) = &create.index.name {
41            write!(
42                sql,
43                "{}{}{}",
44                self.quote().left(),
45                name,
46                self.quote().right()
47            )
48            .unwrap();
49        }
50
51        write!(sql, " ON ").unwrap();
52        if let Some(table) = &create.table {
53            self.prepare_table_ref_index_stmt(table, sql);
54        }
55        write!(sql, " ").unwrap();
56        self.prepare_index_columns(&create.index.columns, sql);
57
58        self.prepare_index_type(&create.index_type, sql);
59    }
60
61    fn prepare_table_ref_index_stmt(&self, table_ref: &TableRef, sql: &mut dyn SqlWriter) {
62        match table_ref {
63            TableRef::Table(_) => self.prepare_table_ref_iden(table_ref, sql),
64            _ => panic!("Not supported"),
65        }
66    }
67    fn prepare_index_drop_statement(&self, drop: &IndexDropStatement, sql: &mut dyn SqlWriter) {
68        write!(sql, "DROP INDEX ").unwrap();
69
70        if drop.if_exists {
71            panic!("Mysql does not support IF EXISTS for DROP INDEX")
72        }
73
74        if let Some(name) = &drop.index.name {
75            write!(
76                sql,
77                "{}{}{}",
78                self.quote().left(),
79                name,
80                self.quote().right()
81            )
82            .unwrap();
83        }
84
85        write!(sql, " ON ").unwrap();
86        if let Some(table) = &drop.table {
87            self.prepare_table_ref_index_stmt(table, sql);
88        }
89    }
90
91    fn prepare_index_type(&self, col_index_type: &Option<IndexType>, sql: &mut dyn SqlWriter) {
92        if let Some(index_type) = col_index_type {
93            if !matches!(index_type, IndexType::FullText) {
94                write!(
95                    sql,
96                    " USING {}",
97                    match index_type {
98                        IndexType::BTree => "BTREE".to_owned(),
99                        IndexType::FullText => unreachable!(),
100                        IndexType::Hash => "HASH".to_owned(),
101                        IndexType::Custom(custom) => custom.to_string(),
102                    }
103                )
104                .unwrap();
105            }
106        }
107    }
108
109    fn prepare_index_prefix(&self, create: &IndexCreateStatement, sql: &mut dyn SqlWriter) {
110        if create.primary {
111            write!(sql, "PRIMARY ").unwrap();
112        }
113        if create.unique {
114            write!(sql, "UNIQUE ").unwrap();
115        }
116        if matches!(create.index_type, Some(IndexType::FullText)) {
117            write!(sql, "FULLTEXT ").unwrap();
118        }
119    }
120}