feat(pgsql): support vector and PostGIS indexes with extensions

* Add handling for pgvector and PostGIS extensions in migration scripts
* Implement operator class and storage parameters for vector indexes
* Update tests to validate new index behaviors and extension creation

pkg/writers/pgsql/migration_writer.go

@@ -164,14 +164,14 @@ func (w *MigrationWriter) WriteMigration(model *models.Database, current *models
 func (w *MigrationWriter) generateSchemaScripts(model *models.Schema, current *models.Schema) ([]MigrationScript, error) {
 	scripts := make([]MigrationScript, 0)
 
-	if schemaRequiresPGTrgm(model) {
+	for _, extension := range requiredExtensions(model) {
 		scripts = append(scripts, MigrationScript{
-			ObjectName: "extension.pg_trgm",
+			ObjectName: "extension." + extension,
 			ObjectType: "create extension",
 			Schema:     model.Name,
 			Priority:   80,
 			Sequence:   len(scripts),
-			Body:       "CREATE EXTENSION IF NOT EXISTS pg_trgm;",
+			Body:       fmt.Sprintf("CREATE EXTENSION IF NOT EXISTS %s;", pgsql.QuoteExtensionName(extension)),
 		})
 	}
 
@@ -646,13 +646,14 @@ func (w *MigrationWriter) generateIndexScripts(model *models.Schema, current *mo
 				}
 
 				sql, err := w.executor.ExecuteCreateIndex(CreateIndexData{
-					SchemaName: model.Name,
-					TableName:  modelTable.Name,
-					IndexName:  indexName,
-					IndexType:  indexType,
-					Columns:    strings.Join(columnExprs, ", "),
-					Unique:     modelIndex.Unique,
-					Concurrent: modelIndex.Concurrent,
+					SchemaName:        model.Name,
+					TableName:         modelTable.Name,
+					IndexName:         indexName,
+					IndexType:         indexType,
+					Columns:           strings.Join(columnExprs, ", "),
+					Unique:            modelIndex.Unique,
+					Concurrent:        modelIndex.Concurrent,
+					StorageParameters: indexStorageParameters(modelIndex.Comment),
 				})
 				if err != nil {
 					return nil, err
@@ -674,20 +675,31 @@ func (w *MigrationWriter) generateIndexScripts(model *models.Schema, current *mo
 	return scripts, nil
 }
 
+// buildIndexColumnExpressions renders the column list of an index, appending the operator
+// class each column needs for the access method (GIN opclasses, pgvector distance ops,
+// explicitly requested PostGIS opclasses). Columns that cannot be resolved on the table are
+// emitted verbatim.
 func buildIndexColumnExpressions(table *models.Table, index *models.Index, indexType string) []string {
+	return buildIndexColumnExpressionsFiltered(table, index, indexType, false)
+}
+
+// buildIndexColumnExpressionsFiltered is buildIndexColumnExpressions with the option to drop
+// columns that do not exist on the table instead of emitting them verbatim.
+func buildIndexColumnExpressionsFiltered(table *models.Table, index *models.Index, indexType string, skipUnresolved bool) []string {
 	columnExprs := make([]string, 0, len(index.Columns))
 	for _, colName := range index.Columns {
-		colExpr := colName
-		if table != nil {
-			if col, ok := resolveIndexColumn(table, colName); ok && col != nil {
-				colExpr = col.SQLName()
-				if strings.EqualFold(indexType, "gin") {
-					opClass := ginOperatorClassForColumn(col, index.Comment)
-					if opClass != "" {
-						colExpr = fmt.Sprintf("%s %s", col.SQLName(), opClass)
-					}
-				}
+		col, ok := resolveIndexColumn(table, colName)
+		if !ok || col == nil {
+			if skipUnresolved {
+				continue
 			}
+			columnExprs = append(columnExprs, colName)
+			continue
+		}
+
+		colExpr := col.SQLName()
+		if opClass := indexOperatorClassForColumn(col, indexType, index.Comment); opClass != "" {
+			colExpr = fmt.Sprintf("%s %s", colExpr, opClass)
 		}
 		columnExprs = append(columnExprs, colExpr)
 	}
@@ -1046,5 +1058,19 @@ func indexesEqual(idx1, idx2 *models.Index) bool {
 			return false
 		}
 	}
-	return true
+	// Operator class and storage parameters ride along in the index comment. They only
+	// signal a difference when both sides specify one, so an index whose model side omits
+	// the hint is not recreated on every migration.
+	if !indexHintsEqual(extractOperatorClass(idx1.Comment), extractOperatorClass(idx2.Comment)) {
+		return false
+	}
+	return indexHintsEqual(indexStorageParameters(idx1.Comment), indexStorageParameters(idx2.Comment))
+}
+
+// indexHintsEqual compares two optional index hints, treating an unspecified hint as a match.
+func indexHintsEqual(hint1, hint2 string) bool {
+	if hint1 == "" || hint2 == "" {
+		return true
+	}
+	return strings.EqualFold(hint1, hint2)
 }