Returns the foreign key constraint with the given name.

        :param name: The constraint name
        :type name: str

        :rtype: ForeignKeyConstraint
351404
def get_foreign_key(self, name):
        
        name = self._normalize_identifier(name)

        if not self.has_foreign_key(name):
            raise ForeignKeyDoesNotExist(name, self._name)

        return self._fk_constraints[name]
182779
public static Constraint nameEquals(String... name)
	{
		return new Field("Named/name", Field.Operation.INTERSECT,
			new HashSet<String>(Arrays.asList(name)));
	}
1054096
def get_id_constraints(pkname, pkey):
  
  if isinstance(pkname, str):
    return {pkname: pkey}
  else:
    return dict(zip(pkname, pkey))
885131
def generic_find_fk_constraint_names(table, columns, referenced, insp):
    """"""
    names = set()

    for fk in insp.get_foreign_keys(table):
        if fk['referred_table'] == referenced and set(fk['referred_columns']) == columns:
            names.add(fk['name'])

    return names
1121730
def field_(self, name):
    
    try:
        field = self.fields[name]
    except KeyError:
        raise KeyError("Key %r not found in '%s'" % (name, self.__class__.__name__))
    return BoundField(self, field, name)
631176
def fake_fk(self, field_name):
        
        return self.djipsum_fields().getOrCreateForeignKey(
            model_class=self.model_class(),
            field_name=field_name
        )
250671
def get_attributes(self, name):
        
        attributes = self._data.get(name, None)
        if not attributes:
            raise RelationReferenceError(
                'Relation \'{name}\' does not exist.'.format(name=name))
        return attributes[:]
522940
protected function getForeignConstraint($name)
    {
        $raw = $this->getConstraint($name);

        if (is_null($raw)) {
            return null;
        }

        return new ForeignConstraint(
            $raw->foreign,
            $raw->references,
            $raw->on,
            strtolower($raw->onDelete),
            strtolower($raw->onUpdate),
            null,
            $raw->selfReferences
        );
    }
782863
def getReferenceSetByName(self, name):
        
        if name not in self._referenceSetNameMap:
            raise exceptions.ReferenceSetNameNotFoundException(name)
        return self._referenceSetNameMap[name]
414584
def where(name)
      # Must define the attributes before constraining them
      raise ArgumentError, "Unknown attribute: #{name}" unless @attributes.include? name
      @constraints[name] = AttributeConstraint.new(name)
    end
1368889
public FKeyModel getFkey(String fkeyName) {
		if (fkeyConstraints == null)
			return null;
		for (FKeyModel fkey : fkeyConstraints)
			if (!StrUtils.isEmpty(fkeyName) && fkeyName.equalsIgnoreCase(fkey.getFkeyName()))
				return fkey;
		return null;
	}
886259
function getConstraintRelId(constraintsNode, name) {
            var relIds = innerCore.getChildrenRelids(constraintsNode);
            var relId;
            for (var i = 0; i < relIds.length; i++) {
                if (name === innerCore.getAttribute(innerCore.getChild(constraintsNode, relIds[i]), 'name')) {
                    relId = relIds[i];
                    break;
                }
            }
            return relId;
        }
1012858
def _maybe_get_default_name(self, name):
        
        if name is None and self.uri.fragment:
            name = self.uri.fragment
        return name
503404
public FKeyModel fkey(String fkeyName) {
		checkReadOnly();
		FKeyModel fkey = new FKeyModel();
		fkey.setTableName(this.tableName);
		fkey.setFkeyName(fkeyName);
		fkey.setTableModel(this);
		getFkeyConstraints().add(fkey);
		return fkey;
	}
168725
private function acquireConstraintName($nameType, $nbr)
    {
        $inputs = array();
        $inputs[] = $this->getDatabase();
        $inputs[] = $this->getCommonName();
        $inputs[] = $nameType;
        $inputs[] = $nbr;

        return NameFactory::generateName(NameFactory::CONSTRAINT_GENERATOR, $inputs);
    }
1347560
def relation(name)
      if @relations.key? name
        Relation.new @context, @relations.fetch(name)
      else
        Relation.new @context, @relations.fetch(name.to_s)
      end
    end
518767
def GetValueByName(self, name):
    
    if not self._registry_key and self._registry:
      self._GetKeyFromRegistry()

    if not self._registry_key:
      return None

    return self._registry_key.GetValueByName(name)