return results
}

func (schema *Schema) LookUpField(name string) *Field {
	if field, ok := schema.FieldsByDBName[name]; ok {
		return field
	}
	if field, ok := schema.FieldsByName[name]; ok {
		return field
	}

	// Lookup field using namer-driven ColumnName
	if schema.namer == nil {
		return nil
	}
	namerColumnName := schema.namer.ColumnName(schema.Table, name)
	if field, ok := schema.FieldsByDBName[namerColumnName]; ok {

		}
		ref.ForeignKey = f
	}

	for name, rel := range relation.JoinTable.Relationships.Relations {
		if _, ok := joinSchema.Relationships.Relations[name]; !ok {
			rel.Schema = joinSchema
			joinSchema.Relationships.Relations[name] = rel
		}
	}
	relation.JoinTable = joinSchema

	return nil
}

// Use use plugin
func (db *DB) Use(plugin Plugin) error {
	name := plugin.Name()

		}

		if DB.Migrator().HasConstraint(&User{}, name) {
			t.Fatalf("constraint %v should been deleted", name)
		}

		if err := DB.Migrator().CreateConstraint(&User{}, name); err != nil {
			t.Fatalf("failed to create constraint %v, got error %v", name, err)
		}

		if !DB.Migrator().HasConstraint(&User{}, name) {
			t.Fatalf("failed to found constraint %v", name)
		}
	}
}

        Integer comp3 = 123;

        ComponentUtil.register(comp1, "name1");
        ComponentUtil.register(comp2, "name2");
        ComponentUtil.register(comp3, "name3");

        assertEquals(comp1, ComponentUtil.getComponent("name1"));
        assertEquals(comp2, ComponentUtil.getComponent("name2"));
        assertEquals(comp3, ComponentUtil.getComponent("name3"));
    }

        assertEquals(engine2, retrievedByClass);

        // But original names should still work
        assertEquals(engine1, scriptEngineFactory.getScriptEngine("name1"));
        assertEquals(engine2, scriptEngineFactory.getScriptEngine("name2"));
    }

    // Test with engine that has very long class name
    @Test
    public void test_add_longClassName() {

        assertEquals("name1", map1.get("name"));

        Map<String, Object> map2 = resultList.get(1);
        assertEquals("name2", map2.get("name"));
    }

    @Test
    public void test_register_entitySet() {
        RenderData data = new RenderData();

        BsUser entity1 = new BsUser();
        entity1.setName("name1");

        BsUser entity2 = new BsUser();

        String name = searcher.getName();
        assertNotNull(name);
        assertTrue(name.equals("my_custom") || name.equals("mycustom"));
    }

    /**
     * Test getName() is cached (lazily initialized).
     */
    @Test
    public void test_getNameCached() {
        final TestSearcher searcher = new TestSearcher();
        final String name1 = searcher.getName();

### Eine benutzerdefinierte Funktion zur Erzeugung einer eindeutigen ID erstellen { #custom-generate-unique-id-function }

FastAPI verwendet eine **eindeutige ID** für jede *Pfadoperation*, die für die **Operation-ID** und auch für die Namen aller benötigten benutzerdefinierten Modelle für Requests oder Responses verwendet wird.

        fw.println("# * Inside the same file: <<(#)section-name(,text)>>");
        fw.println("# * To a different file: <<other-file(.adoc)#section-name,text>> - Note that the # and section are mandatory, otherwise the link is invalid in the single page output");
        fw.println("#");
        fw.println("# The checker does not handle implicit section names, so they must be explicit and declared as: [[section-name]]");
        fw.println("#");

		w.emitf("type %s = %s", name, w.typeString(typ))
		return
	}
	if tparams := obj.Type().(*types.Named).TypeParams(); tparams != nil {
		var buf bytes.Buffer
		buf.WriteString(name)
		w.writeTypeParams(&buf, tparams, true)
		name = buf.String()
	}
	switch typ := typ.Underlying().(type) {
	case *types.Struct:
		w.emitStructType(name, typ)
	case *types.Interface:
		w.emitIfaceType(name, typ)