Dump the text name of the relation.
160462
def dump_type(self, obj):
        """"""
        if not isinstance(obj.relation_type, RelationType):
            return resolve_relation_type_config(obj.relation_type).name
        else:
            return obj.relation_type.name
603280
def encode_relation(relation: BioCRelation):
    """"""
    tree = etree.Element('relation', {'id': relation.id})
    encode_infons(tree, relation.infons)
    for node in relation.nodes:
        tree.append(encode_node(node))
    return tree
610141
private String formatRelation(Relation relation)
   {
      String result = null;

      if (relation != null)
      {
         StringBuilder sb = new StringBuilder(relation.getTargetTask().getID().toString());

         Duration duration = relation.getLag();
         RelationType type = relation.getType();
         double durationValue = duration.getDuration();

         if ((durationValue != 0) || (type != RelationType.FINISH_START))
         {
            String[] typeNames = LocaleData.getStringArray(m_locale, LocaleData.RELATION_TYPES);
            sb.append(typeNames[type.getValue()]);
         }

         if (durationValue != 0)
         {
            if (durationValue > 0)
            {
               sb.append('+');
            }

            sb.append(formatDuration(duration));
         }

         result = sb.toString();
      }

      m_eventManager.fireRelationWrittenEvent(relation);
      return (result);
   }
913846
def dumps(self):
        """

        content = self.dumps_content()

        if not content.strip() and self.omit_if_empty:
            return ''

        string = ''

        start = Command(self.latex_name, arguments=self.arguments,
                        options=self.options)

        string += start.dumps() + '{ \n'

        if content != '':
            string += content + '\n}'
        else:
            string += '}'

        return string
681422
def dump(self):
        """"""
        for modpath in sorted(self.map):
            title = 'Imports in %s' % modpath
            print('\n' + title + '\n' + '-'*len(title))
            for name, value in sorted(self.map.get(modpath, {}).items()):
                print('  %s -> %s' % (name, ', '.join(sorted(value))))
187124
def output_names(self) -> Iterable[str]:
        """"""
        self._load_models()
        return chain.from_iterable(map(lambda m: m.output_names, self._models))
1198234
def dump(self, name: str, inst):
        ""
        self.stash.dump(name, inst)
1023058
def _dump_model(model, attrs=None):
    

    fields = []

    for field in model._meta.fields:
        fields.append((field.name, str(getattr(model, field.name))))

    if attrs is not None:
        for attr in attrs:
            fields.append((attr, str(getattr(model, attr))))

    for field in model._meta.many_to_many:
        vals = getattr(model, field.name)
        fields.append((field.name, '{val} ({count})'.format(
            val=', '.join(map(str, vals.all())),
            count=vals.count(),
        )))

    print(', '.join(
        '{0}={1}'.format(field, value)
        for field, value in fields
    ))
1259265
def quote_names(db, names):
    """"""
    c = db.cursor()
    c.execute("SELECT pg_catalog.quote_ident(n) FROM pg_catalog.unnest(%s::text[]) n", [list(names)])
    return [name for (name,) in c]
1194262
public function Dump( ) {

    /**
      *
      * The method Dump( ) displays the reference graph in textual form
      *
      * Example:
      *
      */


      echo "\nDump für cReferenceGraph";

      for ( $i = 0; $i < count( $this->m_a_references ); $i++ ) {

	echo ( "\n $i  " . $this->m_a_references[$i]->m_table_name . ' ( ' );

	    for ($j = 0; $j <count($this->m_a_references[$i]->m_a_references); $j++) {

		echo " " . $this->m_a_references[$i]->m_a_references[$j]->m_TABLE_NAME;

	    }

	echo ")\n";


      }


  }
296086
def _dump(self, tree):
        
        schema = []
        if tree.tables:
            for table in tree.tables:
                desc = self.describe(table, refresh=True, require=True)
                schema.append(desc.schema)
        else:
            for table in self.describe_all():
                schema.append(table.schema)

        return "\n\n".join(schema)
378632
public String getRelationshipName()
    {
        String ret;
        if (tableAB == null /* && multipleRelationsBetweenTables */)
        {
            ret = concatenateColumnNames(this);
            ret = ret.substring(1); // remove leading _.
        }
        else // Many-to-Many relationship
        {
            ForeignKey[] fks = tableAB.getForeignKeys().values().toArray(new ForeignKey[2]);
            ret = ForeignKey.concatenateColumnNames(fks[1]).substring(1);
        }

        String multiplicity = getTableBMultiplicity();
        if (!multiplicity.equals("one"))
            ret = StringUtility.englishPluralize(ret);
        return ret;
    }
565534
private function getRelationsForeignKeyName(HasOneOrMany $relation): string
	{
		return method_exists($relation, 'getForeignKeyName') ? $relation->getForeignKeyName() : $relation->getPlainForeignKey();
	}
1305686
def relations_to(self, target, include_object=False):
        '''  '''
        if include_object:
            _ = self._execute('''
                select name, (select code from objects where id=src) from relations where dst=?
            ''', (self._id_of(target),))
            for i in _:
                yield self.deserialize(i[1]), i[0]
        else:
            _ = self._execute('''
                select distinct name from relations where dst=?
            ''', (self._id_of(target),))
            for i in _:
                yield i[0]
541774
def dump(self, name):
        
        with self.pipe as pipe:
            return pipe.dump(self.redis_key(name))
1170387
def Dump(title=None):
    
    if title:
        print(title)
    for counter in sorted(CounterList):
        CounterList[counter].display()
242545
def delete_relation(self, src, relation, target):
        '''  '''
        self.__require_string__(relation)
        if src in self and target in self:
            self._get_item_node(src).unlink(relation, self._get_item_node(target))