return "CONSTRAINT ? UNIQUE (?)", []interface{}{clause.Column{Name: uni.Name}, clause.Column{Name: uni.Field.DBName}}
}

// ParseUniqueConstraints parse schema unique constraints
func (schema *Schema) ParseUniqueConstraints() map[string]UniqueConstraint {
	uniques := make(map[string]UniqueConstraint)
	for _, field := range schema.Fields {
		if field.Unique {

    sort(contents, 0, n, comparator);
    int uniques = 1;
    for (int i = 1; i < n; i++) {
      E cur = contents[i];
      E prev = contents[uniques - 1];
      if (comparator.compare(cur, prev) != 0) {
        contents[uniques++] = cur;
      }
    }
    Arrays.fill(contents, uniques, n, null);
    if (uniques < contents.length / 2) {

Vous devez vous assurer qu'il est unique pour chaque opération.

{* ../../docs_src/path_operation_advanced_configuration/tutorial001.py hl[6] *}

    }

    /**
     * Finds a scheduled job by its unique identifier.
     *
     * @param jobUnique the unique identifier of the job
     * @return an optional containing the scheduled job if found, empty otherwise
     */
    private OptionalThing<LaScheduledJob> findJobByUniqueOf(final LaJobUnique jobUnique) {
        final JobManager jobManager = ComponentUtil.getJobManager();
        try {

)

func bytediff(a, b []byte) string {
	const (
		uniqueA  = "-  "
		uniqueB  = "+  "
		identity = "   "
	)
	var ss []string
	sa := strings.Split(strings.TrimSpace(hex.Dump(a)), "\n")
	sb := strings.Split(strings.TrimSpace(hex.Dump(b)), "\n")
	for len(sa) > 0 && len(sb) > 0 {
		if sa[0] == sb[0] {
			ss = append(ss, identity+sa[0])
		} else {
			ss = append(ss, uniqueA+sa[0])
			ss = append(ss, uniqueB+sb[0])
		}

            return userCode;
        }
        return null;
    }

    /**
     * Generates a new unique identifier for user tracking.
     * Creates a UUID and removes hyphens to create a clean identifier string.
     *
     * @return a new unique identifier string
     */
    protected String getId() {
        return UUID.randomUUID().toString().replace("-", StringUtil.EMPTY);
    }

}

func TestParseIndexWithUniqueIndexAndUnique(t *testing.T) {
	type IndexTest struct {
		FieldA string `gorm:"unique;index"` // unique and index
		FieldB string `gorm:"unique"`       // unique

		FieldC string `gorm:"index:,unique"`     // uniqueIndex
		FieldD string `gorm:"uniqueIndex;index"` // uniqueIndex and index

		FieldE1 string `gorm:"uniqueIndex:uniq_field_e1_e2"` // mul uniqueIndex

		if field == nil {
			t.Fatalf("%v: failed to find column %q", utils.FileWithLineNum(), fieldName)
		}
		if field.Unique != unique {
			t.Fatalf("%v: %q column %q unique should be %v but got %v", utils.FileWithLineNum(), stmt.Schema.Table, fieldName, unique, field.Unique)
		}
		if field.UniqueIndex != uniqueIndex {

		if err != nil {
			t.Fatalf("failed to parse user unique, got error %v", err)
		}

		constraints := user.ParseUniqueConstraints()
		if len(constraints) != 1 {
			t.Fatalf("failed to find unique constraint, got %v", constraints)
		}

		for key := range constraints {
			if len(key) != 63 {
				t.Errorf("failed to find unique constraint, got %v", constraints)
			}
		}
	})

			Name:  "uni_user_uniques_name1",
			Field: &schema.Field{Name: "Name1", Unique: true},
		},
	}
	for k, result := range results {
		v, ok := constraints[k]
		if !ok {
			t.Errorf("Failed to found unique constraint %v from parsed constraints %+v", k, constraints)
		}
		tests.AssertObjEqual(t, result, v, "Name")
		tests.AssertObjEqual(t, result.Field, v.Field, "Name", "Unique", "UniqueIndex")
	}