Name       string
	Constraint string // length(phone) >= 10
	*Field
}

func (chk *CheckConstraint) GetName() string { return chk.Name }

func (chk *CheckConstraint) Build() (sql string, vars []interface{}) {
	return "CONSTRAINT ? CHECK (?)", []interface{}{clause.Column{Name: chk.Name}, clause.Expr{SQL: chk.Constraint}}
}

// ParseCheckConstraints parse schema check constraints

        1 * dependencyConstraintFactory.createDependencyConstraint("someOther") >> constraint2
        1 * dependencyConstraintSet.add(constraint1)
        1 * dependencyConstraintSet.add(constraint2)
    }

    void "can use dynamic method to add multiple dependency constraint from nested lists"() {
        def constraint1 = Mock(DependencyConstraint)

        constraints.add(this, dependencyConstraintNotation)

    /**
     * Adds a dependency constraint to the given configuration.
     *
     * @param dependencyConstraintNotation notation for the dependency constraint to be added.
     * @param configuration expression to use to configure the dependency constraint.
     * @return The dependency constraint.
     * @see [DependencyConstraintHandler.add]

        protected final List<Object> constraints;

        public RecursiveOrderSpec(List<Object> constraints) {
            this.constraints = constraints;
        }

        protected int checkConstraint(Object constraint, int lastIndex, List<String> executedTaskPaths) {
            int index;
            if (constraint instanceof String) {
                index = executedTaskPaths.indexOf(constraint);

  // Collect `dst_root` constraints that are applicable to the values defined in
  // the `src_root` cluster.
  ValuesConstraintSet constraints = members[src_root].constraints;
  members[dst_root].constraints.Walk([&](Value v, ValueConstraint constraint) {
    Operation *op = v.getDefiningOp();
    if (op && filter(op)) constraints.Insert(v, constraint);
  });

            }
        }
    }

    def "a strict constraint wins over a nested strict constraint"() {
        boolean publishedConstraintsSupported = gradleMetadataPublished

        given:
        repository {
            'org:a:1.0' {
                dependsOn(group: 'org', artifact: 'b', version: '1.0')
                constraint(group: 'org', artifact: 'c', strictly: '2.0')
            }

        given:
        repository {
            'org:platform:1.0'() {
                constraint(group: 'org', artifact: 'bar', version: '1.0')
                constraint(group: 'org', artifact: 'foo', strictly: '1.0')
            }
            'org:platform:2.0'() {
                constraint(group: 'org', artifact: 'bar', version: '1.0')
                constraint(group: 'org', artifact: 'foo', version: '1.0')
            }
            'org:foo:1.0'()

                    if (available) {
                        if (GradleMetadataResolveRunner.gradleMetadataPublished) {
                            constraint("org:foo:1.1", "org:foo:1.1").byConstraint('published dependency constraint')
                        } else {
                            constraint("org:foo:1.1", "org:foo:1.1")
                        }
                    }
                }
                if (available) {

        PLATFORM,          // constraints in platform are published with strict constraints, consumer uses 'platform()' dependencies
        // The recommended way of dealing with existing platforms
        LEGACY_PLATFORM,   // constraints in platform are published without strict constraints, consumer uses 'platform()' dependencies + component metadata rules to make all published constraints strict

        javaPlatform.assertPublished()
        javaPlatform.parsedModuleMetadata.variant("apiElements") {
            constraint("org.test:foo:1.0")
            noMoreDependencies()
        }
        javaPlatform.parsedModuleMetadata.variant("runtimeElements") {
            constraint("org.test:foo:1.0")
            constraint("org.test:bar:1.0")
            noMoreDependencies()
        }