sql = "CONSTRAINT ? FOREIGN KEY ? REFERENCES ??"
	if constraint.OnDelete != "" {
		sql += " ON DELETE " + constraint.OnDelete
	}

	if constraint.OnUpdate != "" {
		sql += " ON UPDATE " + constraint.OnUpdate
	}

	foreignKeys := make([]interface{}, 0, len(constraint.ForeignKeys))
	for _, field := range constraint.ForeignKeys {
		foreignKeys = append(foreignKeys, clause.Column{Name: field.DBName})

						if rel.Field.IgnoreMigration {
							continue
						}
						if constraint := rel.ParseConstraint(); constraint != nil &&
							constraint.Schema == stmt.Schema && !queryTx.Migrator().HasConstraint(value, constraint.Name) {
							if err := execTx.Migrator().CreateConstraint(value, constraint.Name); err != nil {
								return err
							}
						}
					}
				}

        assertNotNull(documented);
    }

    // Test annotation has Constraint meta-annotation
    @Test
    public void test_annotationConstraint() {
        jakarta.validation.Constraint constraint = CronExpression.class.getAnnotation(jakarta.validation.Constraint.class);
        assertNotNull(constraint);
        Class<?>[] validators = constraint.validatedBy();
        assertEquals(1, validators.length);

    }

    // Test Constraint annotation
    @Test
    public void test_constraintAnnotation() {
        final Constraint constraint = CustomSize.class.getAnnotation(Constraint.class);
        assertNotNull(constraint, "Constraint annotation should be present");
        assertEquals("Validator class should be CustomSizeValidator", CustomSizeValidator.class, constraint.validatedBy()[0]);
    }

    }

    // Test Constraint annotation
    @Test
    public void test_constraintAnnotation() {
        final Constraint constraint = UriType.class.getAnnotation(Constraint.class);
        assertNotNull(constraint, "Constraint annotation should be present");
        assertEquals("Validator class should be UriTypeValidator", UriTypeValidator.class, constraint.validatedBy()[0]);

	}

	if name := DB.Dialector.Name(); name == "postgres" {
		t.Skip("skip postgres due to it only allow unique constraint matching given keys")
	}
	if name := DB.Dialector.Name(); name == "gaussdb" {
		t.Skip("skip gaussdb due to it only allow unique constraint matching given keys")
	}

	DB.Migrator().DropTable(&Blog{}, &Tag{}, "blog_tags", "locale_blog_tags", "shared_blog_tags")

        // Test constraint message constants
        assertEquals("{constraints.AssertFalse.message}", FessMessages.CONSTRAINTS_AssertFalse_MESSAGE);
        assertEquals("{constraints.AssertTrue.message}", FessMessages.CONSTRAINTS_AssertTrue_MESSAGE);
        assertEquals("{constraints.DecimalMax.message}", FessMessages.CONSTRAINTS_DecimalMax_MESSAGE);

  }

  @Override
  protected Map<Class<? extends @NonNull B>, B> delegate() {
    return delegate;
  }

  /**
   * Wraps the {@code setValue} implementation of an {@code Entry} to enforce the class constraint.
   */
  private static <B extends @Nullable Object> Entry<Class<? extends @NonNull B>, B> checkedEntry(
      Entry<Class<? extends @NonNull B>, B> entry) {
    return new ForwardingMapEntry<Class<? extends @NonNull B>, B>() {

  protected void setUp() throws Exception {
    map = MutableClassToInstanceMap.create();
  }

  public void testConstraint() {
    /*
     * We'll give ourselves a pass on testing all the possible ways of breaking the constraint,
     * because we know that newClassMap() is implemented using ConstrainedMap which is itself
     * well-tested. A purist would object to this, but what can I say, we're dirty cheaters.
     */

After testing several alternatives, I decided that I was going to use [**Pydantic**](https://docs.pydantic.dev/) for its advantages.

Then I contributed to it, to make it fully compliant with JSON Schema, to support different ways to define constraint declarations, and to improve editor support (type checks, autocompletion) based on the tests in several editors.

During the development, I also contributed to [**Starlette**](https://www.starlette.dev/), the other key requirement.