Query to check for index existence

src/mysql/probe.rs

@@ -1,8 +1,9 @@
-use sea_query::{Condition, Expr, Query, SelectStatement, SimpleExpr};
+use sea_query::{Condition, Expr, Iden, Query, SelectStatement, SimpleExpr};
 
 use super::query::{InformationSchema as Schema, TablesFields};
 use super::MySql;
-use crate::probe::SchemaProbe;
+use crate::mysql::query::InformationSchema;
+use crate::probe::{DatabaseSchema, Has, SchemaProbe};
 
 impl SchemaProbe for MySql {
     fn get_current_schema() -> SimpleExpr {
@@ -21,4 +22,26 @@ impl SchemaProbe for MySql {
             )
             .take()
     }
+
+    fn has_index<T, C>(table: T, index: C) -> SelectStatement
+    where
+        T: AsRef<str>,
+        C: AsRef<str>,
+    {
+        Query::select()
+            .expr_as(Expr::cust("COUNT(*) > 0"), Has::Index)
+            .from((DatabaseSchema::Info, InformationSchema::Statistics))
+            .cond_where(
+                Condition::all()
+                    .add(Expr::col(DatabaseSchema::TableSchema).eq(Self::get_current_schema()))
+                    .add(Expr::col(DatabaseSchema::TableName).eq(table.as_ref()))
+                    .add(Expr::col(InternalDatabaseSchema::IndexName).eq(index.as_ref())),
+            )
+            .take()
+    }
+}
+
+#[derive(Debug, Iden)]
+pub enum InternalDatabaseSchema {
+    IndexName,
 }

src/postgres/probe.rs

@@ -1,8 +1,8 @@
-use sea_query::{Condition, Expr, Query, SelectStatement, SimpleExpr};
+use sea_query::{Alias, Condition, Expr, Iden, Query, SelectStatement, SimpleExpr};
 
 use super::query::{InformationSchema as Schema, TablesFields};
 use super::Postgres;
-use crate::probe::SchemaProbe;
+use crate::probe::{Has, SchemaProbe};
 
 impl SchemaProbe for Postgres {
     fn get_current_schema() -> SimpleExpr {
@@ -23,4 +23,31 @@ impl SchemaProbe for Postgres {
             )
             .take()
     }
+
+    fn has_index<T, C>(table: T, index: C) -> SelectStatement
+    where
+        T: AsRef<str>,
+        C: AsRef<str>,
+    {
+        Query::select()
+            .expr_as(Expr::cust("COUNT(*) > 0"), Has::Index)
+            .from(Alias::new("pg_indexes"))
+            .cond_where(
+                Condition::all()
+                    .add(Expr::col(DatabaseSchema::Schema).eq(Self::get_current_schema()))
+                    .add(Expr::col(DatabaseSchema::Table).eq(table.as_ref()))
+                    .add(Expr::col(DatabaseSchema::Index).eq(index.as_ref())),
+            )
+            .take()
+    }
+}
+
+#[derive(Debug, Iden)]
+enum DatabaseSchema {
+    #[iden = "tablename"]
+    Table,
+    #[iden = "schemaname"]
+    Schema,
+    #[iden = "indexname"]
+    Index,
 }

src/probe.rs

@@ -10,7 +10,7 @@ pub trait SchemaProbe {
         T: AsRef<str>,
     {
         let mut subquery = Self::query_tables();
-        subquery.cond_where(Expr::col(Schema::TableName).eq(table.as_ref()));
+        subquery.cond_where(Expr::col(DatabaseSchema::TableName).eq(table.as_ref()));
         Query::select()
             .expr_as(Expr::cust("COUNT(*) > 0"), Has::Table)
             .from_subquery(subquery, Subquery)
@@ -24,30 +24,37 @@ pub trait SchemaProbe {
     {
         Query::select()
             .expr_as(Expr::cust("COUNT(*) > 0"), Has::Column)
-            .from((Schema::Info, Schema::Columns))
+            .from((DatabaseSchema::Info, DatabaseSchema::Columns))
             .cond_where(
                 Condition::all()
                     .add(
                         Expr::expr(Self::get_current_schema())
-                            .equals((Schema::Columns, Schema::TableSchema)),
+                            .equals((DatabaseSchema::Columns, DatabaseSchema::TableSchema)),
                     )
-                    .add(Expr::col(Schema::TableName).eq(table.as_ref()))
-                    .add(Expr::col(Schema::ColumnName).eq(column.as_ref())),
+                    .add(Expr::col(DatabaseSchema::TableName).eq(table.as_ref()))
+                    .add(Expr::col(DatabaseSchema::ColumnName).eq(column.as_ref())),
             )
             .take()
     }
+
+    fn has_index<T, C>(table: T, index: C) -> SelectStatement
+    where
+        T: AsRef<str>,
+        C: AsRef<str>;
 }
 
 #[derive(Debug, Iden)]
-enum Has {
+pub enum Has {
     #[iden = "has_table"]
     Table,
     #[iden = "has_column"]
     Column,
+    #[iden = "has_index"]
+    Index,
 }
 
 #[derive(Debug, Iden)]
-enum Schema {
+pub enum DatabaseSchema {
     #[iden = "information_schema"]
     Info,
     Columns,

src/sqlite/probe.rs

@@ -2,7 +2,7 @@ use sea_query::{Condition, Expr, Iden, IntoTableRef, Query, SelectStatement, Sim
 
 use super::query::SqliteMaster;
 use super::Sqlite;
-use crate::probe::SchemaProbe;
+use crate::probe::{Has, SchemaProbe};
 
 impl SchemaProbe for Sqlite {
     fn get_current_schema() -> SimpleExpr {
@@ -34,11 +34,29 @@ impl SchemaProbe for Sqlite {
             .and_where(Expr::col(Schema::Name).eq(column.as_ref()))
             .take()
     }
+
+    fn has_index<T, C>(table: T, index: C) -> SelectStatement
+    where
+        T: AsRef<str>,
+        C: AsRef<str>,
+    {
+        Query::select()
+            .expr_as(Expr::cust("COUNT(*) > 0"), Has::Index)
+            .from(SqliteMaster.into_table_ref())
+            .cond_where(
+                Condition::all()
+                    .add(Expr::col(Schema::Type).eq("index"))
+                    .add(Expr::col(Schema::TblName).eq(table.as_ref()))
+                    .add(Expr::col(Schema::Name).eq(index.as_ref())),
+            )
+            .take()
+    }
 }
 
 #[derive(Debug, Iden)]
 enum Schema {
     Name,
     Type,
     TableName,
+    TblName,
 }