feat(schema): add partial index support for @@unique and @@index

Add support for partial indexes with WHERE clauses in Prisma Schema Language.

Features:
- New raw() syntax for WHERE clauses: @@unique([email], where: raw("status = 'active'"))
- Object literal syntax for conditions: @@unique([email], where: { active: true })
  - Supports: boolean (true/false), null, string, and number values
  - Conditions: equals, not equals (!=), IS NULL, IS NOT NULL
- Support for PostgreSQL, SQLite, SQL Server (filtered indexes), and CockroachDB
- Preview feature flag: partialIndexes
- Auto-injection of preview feature during introspection

Schema Engine:
- SQL generation for partial indexes across all supported databases
- Migration diffing with predicate comparison
- Introspection of existing partial indexes
- CockroachDB limitation handling (cannot introspect predicate text)

SQL Server specifics:
- Filtered unique indexes created via CREATE INDEX (not table constraints)
- Predicate normalization for consistent diffing

Tests:
- Comprehensive migration tests for all supported databases
- Introspection tests for PostgreSQL, SQLite, SQL Server, and CockroachDB

Author: jay-l-e-e

libs/sql-ddl/src/postgres.rs

@@ -347,6 +347,7 @@ pub struct CreateIndex<'a> {
     pub table_reference: &'a dyn Display,
     pub columns: Vec<IndexColumn<'a>>,
     pub using: Option<IndexAlgorithm>,
+    pub where_clause: Option<Cow<'a, str>>,
 }
 
 impl Display for CreateIndex<'_> {
@@ -388,7 +389,13 @@ impl Display for CreateIndex<'_> {
             })
             .join(", ", f)?;
 
-        f.write_str(")")
+        f.write_str(")")?;
+
+        if let Some(predicate) = &self.where_clause {
+            write!(f, " WHERE {}", predicate)?;
+        }
+
+        Ok(())
     }
 }
 
@@ -432,6 +439,7 @@ mod tests {
             table_reference: &PostgresIdentifier::Simple(Cow::Borrowed("Cat")),
             columns,
             using: None,
+            where_clause: None,
         };
 
         assert_eq!(
@@ -450,6 +458,7 @@ mod tests {
             table_reference: &PostgresIdentifier::Simple(Cow::Borrowed("Cat")),
             columns,
             using: Some(IndexAlgorithm::Hash),
+            where_clause: None,
         };
 
         assert_eq!(
@@ -479,6 +488,7 @@ mod tests {
             table_reference: &PostgresIdentifier::Simple("Cat".into()),
             columns,
             using: None,
+            where_clause: None,
         };
 
         assert_eq!(
@@ -487,6 +497,25 @@ mod tests {
         )
     }
 
+    #[test]
+    fn create_partial_unique_index() {
+        let columns = vec![IndexColumn::new("name")];
+
+        let create_index = CreateIndex {
+            is_unique: true,
+            index_name: "meow_idx".into(),
+            table_reference: &PostgresIdentifier::Simple(Cow::Borrowed("Cat")),
+            columns,
+            using: None,
+            where_clause: Some("status = 'active'".into()),
+        };
+
+        assert_eq!(
+            create_index.to_string(),
+            "CREATE UNIQUE INDEX \"meow_idx\" ON \"Cat\"(\"name\") WHERE status = 'active'"
+        )
+    }
+
     #[test]
     fn full_alter_table_add_foreign_key() {
         let alter_table = AlterTable {

libs/sql-ddl/src/sqlite.rs

@@ -148,6 +148,55 @@ impl Display for Column<'_> {
     }
 }
 
+/// A column in an index definition.
+#[derive(Debug, Default)]
+pub struct IndexColumn<'a> {
+    pub name: Cow<'a, str>,
+    pub sort_order: Option<crate::SortOrder>,
+}
+
+/// Create an index statement.
+#[derive(Debug)]
+pub struct CreateIndex<'a> {
+    pub index_name: Cow<'a, str>,
+    pub table_name: Cow<'a, str>,
+    pub columns: Vec<IndexColumn<'a>>,
+    pub is_unique: bool,
+    pub where_clause: Option<Cow<'a, str>>,
+}
+
+impl Display for CreateIndex<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "CREATE {uniqueness}INDEX \"{index_name}\" ON \"{table_name}\"(",
+            uniqueness = if self.is_unique { "UNIQUE " } else { "" },
+            index_name = self.index_name,
+            table_name = self.table_name,
+        )?;
+
+        self.columns
+            .iter()
+            .map(|c| {
+                let mut rendered = format!("\"{}\"", c.name);
+                if let Some(sort_order) = c.sort_order {
+                    rendered.push(' ');
+                    rendered.push_str(sort_order.as_ref());
+                }
+                rendered
+            })
+            .join(", ", f)?;
+
+        f.write_str(")")?;
+
+        if let Some(predicate) = &self.where_clause {
+            write!(f, " WHERE {}", predicate)?;
+        }
+
+        Ok(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -270,4 +319,42 @@ mod tests {
 
         assert_eq!(create_table.to_string(), expected.trim_matches('\n'))
     }
+
+    #[test]
+    fn create_unique_index() {
+        let create_index = CreateIndex {
+            index_name: "idx_name".into(),
+            table_name: "Cat".into(),
+            columns: vec![IndexColumn {
+                name: "name".into(),
+                sort_order: None,
+            }],
+            is_unique: true,
+            where_clause: None,
+        };
+
+        assert_eq!(
+            create_index.to_string(),
+            r#"CREATE UNIQUE INDEX "idx_name" ON "Cat"("name")"#
+        )
+    }
+
+    #[test]
+    fn create_partial_unique_index() {
+        let create_index = CreateIndex {
+            index_name: "idx_name".into(),
+            table_name: "Cat".into(),
+            columns: vec![IndexColumn {
+                name: "name".into(),
+                sort_order: None,
+            }],
+            is_unique: true,
+            where_clause: Some("status = 'active'".into()),
+        };
+
+        assert_eq!(
+            create_index.to_string(),
+            r#"CREATE UNIQUE INDEX "idx_name" ON "Cat"("name") WHERE status = 'active'"#
+        )
+    }
 }

psl/parser-database/src/attributes.rs

@@ -12,7 +12,8 @@ use crate::{
     context::Context,
     types::{
         CompositeTypeField, EnumAttributes, FieldWithArgs, IndexAlgorithm, IndexAttribute, IndexFieldPath, IndexType,
-        ModelAttributes, OperatorClassStore, RelationField, ScalarField, ScalarFieldType, SortOrder,
+        ModelAttributes, OperatorClassStore, RelationField, ScalarField, ScalarFieldType, SortOrder, WhereClause,
+        WhereCondition, WhereFieldCondition, WhereValue,
     },
     walkers::RelationFieldId,
 };
@@ -536,6 +537,7 @@ fn model_index(data: &mut ModelAttributes, model_id: crate::ModelId, ctx: &mut C
 
     index_attribute.algorithm = algo;
     index_attribute.clustered = validate_clustering_setting(ctx);
+    index_attribute.where_clause = parse_where_clause(ctx);
 
     data.ast_indexes.push((ctx.current_attribute_id().1, index_attribute));
 }
@@ -592,10 +594,134 @@ fn model_unique(data: &mut ModelAttributes, model_id: crate::ModelId, ctx: &mut
     index_attribute.name = name;
     index_attribute.mapped_name = mapped_name;
     index_attribute.clustered = validate_clustering_setting(ctx);
+    index_attribute.where_clause = parse_where_clause(ctx);
 
     data.ast_indexes.push((current_attribute_id.1, index_attribute));
 }
 
+/// Parse the `where` argument for partial indexes.
+fn parse_where_clause(ctx: &mut Context<'_>) -> Option<WhereClause> {
+    let expression = ctx.visit_optional_arg("where")?;
+
+    // Object syntax: { field: value, ... }
+    if let Some((members, _span)) = expression.as_object() {
+        if members.is_empty() {
+            ctx.push_attribute_validation_error("The `where` argument cannot be an empty object.");
+            return None;
+        }
+
+        let mut conditions = Vec::new();
+
+        for member in members {
+            conditions.push(parse_where_object_member(member, ctx)?);
+        }
+
+        return Some(WhereClause::Object(conditions));
+    }
+
+    // raw("...") function call
+    if let Some(("raw", args)) = coerce::function(expression, ctx.diagnostics) {
+        return parse_raw_where_clause(args, ctx);
+    }
+
+    ctx.push_attribute_validation_error(
+        "The `where` argument must be either a raw() function call or an object literal, e.g. `where: raw(\"status = 'active'\")` or `where: { active: true }`.",
+    );
+
+    None
+}
+
+/// Parse raw("...") where clause.
+fn parse_raw_where_clause(args: &[ast::Argument], ctx: &mut Context<'_>) -> Option<WhereClause> {
+    let Some(first_arg) = args.first() else {
+        ctx.push_attribute_validation_error(
+            "The `where` argument must be a raw() function with a string argument, e.g. `where: raw(\"status = 'active'\")`.",
+        );
+        return None;
+    };
+
+    let Some(predicate) = coerce::string(&first_arg.value, ctx.diagnostics) else {
+        ctx.push_attribute_validation_error(
+            "The `where` argument must be a raw() function with a string argument, e.g. `where: raw(\"status = 'active'\")`.",
+        );
+        return None;
+    };
+
+    if predicate.is_empty() {
+        ctx.push_attribute_validation_error("The `where` argument cannot contain an empty string.");
+        return None;
+    }
+
+    Some(WhereClause::Raw(ctx.interner.intern(predicate)))
+}
+
+fn parse_where_object_member(member: &ast::ObjectMember, ctx: &mut Context<'_>) -> Option<WhereFieldCondition> {
+    let field_name = ctx.interner.intern(&member.key);
+
+    let condition = match &member.value {
+        ast::Expression::ConstantValue(val, _) => match val.as_str() {
+            "true" => WhereCondition::Equals(WhereValue::Boolean(true)),
+            "false" => WhereCondition::Equals(WhereValue::Boolean(false)),
+            "null" => WhereCondition::IsNull,
+            other => {
+                ctx.push_attribute_validation_error(&format!(
+                    "Invalid value '{other}' in where clause. Expected true, false, null, a string, a number, or an object like {{ not: null }}."
+                ));
+                return None;
+            }
+        },
+        ast::Expression::StringValue(val, _) => WhereCondition::Equals(WhereValue::String(ctx.interner.intern(val))),
+        ast::Expression::NumericValue(val, _) => WhereCondition::Equals(WhereValue::Number(ctx.interner.intern(val))),
+        ast::Expression::Object(inner_members, _) => {
+            if inner_members.len() != 1 {
+                ctx.push_attribute_validation_error(
+                    "Nested object in where clause must have exactly one key. Use `{ not: null }` or `{ not: \"value\" }`.",
+                );
+                return None;
+            }
+
+            let inner = &inner_members[0];
+            if inner.key != "not" {
+                ctx.push_attribute_validation_error(&format!(
+                    "Unknown key '{}' in nested where clause object. Only 'not' is supported.",
+                    inner.key
+                ));
+                return None;
+            }
+
+            match &inner.value {
+                ast::Expression::ConstantValue(val, _) if val == "null" => WhereCondition::IsNotNull,
+                ast::Expression::StringValue(val, _) => {
+                    WhereCondition::NotEquals(WhereValue::String(ctx.interner.intern(val)))
+                }
+                ast::Expression::NumericValue(val, _) => {
+                    WhereCondition::NotEquals(WhereValue::Number(ctx.interner.intern(val)))
+                }
+                ast::Expression::ConstantValue(val, _) if val == "true" => {
+                    WhereCondition::NotEquals(WhereValue::Boolean(true))
+                }
+                ast::Expression::ConstantValue(val, _) if val == "false" => {
+                    WhereCondition::NotEquals(WhereValue::Boolean(false))
+                }
+                _ => {
+                    ctx.push_attribute_validation_error(
+                        "Invalid value for 'not' in where clause. Expected null, a string, a number, or a boolean.",
+                    );
+                    return None;
+                }
+            }
+        }
+        _ => {
+            ctx.push_attribute_validation_error(
+                "Invalid value in where clause. Expected true, false, null, a string, a number, or an object like { not: null }.",
+            );
+            return None;
+        }
+    };
+
+    Some(WhereFieldCondition { field_name, condition })
+}
+
 fn common_index_validations(
     index_data: &mut IndexAttribute,
     model_id: crate::ModelId,

psl/parser-database/src/types.rs

@@ -528,6 +528,54 @@ pub enum IndexType {
     Fulltext,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum WhereCondition {
+    IsNull,
+    IsNotNull,
+    Equals(WhereValue),
+    NotEquals(WhereValue),
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub(crate) enum WhereValue {
+    String(StringId),
+    Number(StringId),
+    Boolean(bool),
+}
+
+impl WhereValue {
+    pub(crate) fn to_sql(&self, db: &ParserDatabase) -> String {
+        match self {
+            WhereValue::String(s) => format!("'{}'", db[*s].replace('\'', "''")),
+            WhereValue::Number(n) => db[*n].to_string(),
+            WhereValue::Boolean(b) => b.to_string(),
+        }
+    }
+}
+
+impl WhereCondition {
+    pub(crate) fn to_sql(&self, field_name: &str, db: &ParserDatabase) -> String {
+        match self {
+            WhereCondition::IsNull => format!("{field_name} IS NULL"),
+            WhereCondition::IsNotNull => format!("{field_name} IS NOT NULL"),
+            WhereCondition::Equals(v) => format!("{field_name} = {}", v.to_sql(db)),
+            WhereCondition::NotEquals(v) => format!("{field_name} != {}", v.to_sql(db)),
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub(crate) struct WhereFieldCondition {
+    pub(crate) field_name: StringId,
+    pub(crate) condition: WhereCondition,
+}
+
+#[derive(Debug, Clone)]
+pub(crate) enum WhereClause {
+    Raw(StringId),
+    Object(Vec<WhereFieldCondition>),
+}
+
 #[derive(Debug, Default)]
 pub(crate) struct IndexAttribute {
     pub(crate) r#type: IndexType,
@@ -537,6 +585,7 @@ pub(crate) struct IndexAttribute {
     pub(crate) mapped_name: Option<StringId>,
     pub(crate) algorithm: Option<IndexAlgorithm>,
     pub(crate) clustered: Option<bool>,
+    pub(crate) where_clause: Option<WhereClause>,
 }
 
 impl IndexAttribute {