if db.Error == nil && db.Statement.Schema != nil {
			selectColumns, restricted := db.Statement.SelectAndOmitColumns(create, !create)

			// Save Has One associations
			for _, rel := range db.Statement.Schema.Relationships.HasOne {
				if v, ok := selectColumns[rel.Name]; (ok && !v) || (!ok && restricted) {
					continue
				}

				switch db.Statement.ReflectValue.Kind() {
				case reflect.Slice, reflect.Array:
					var (

        runtime.registerData("adminUser",
                fessConfig.isAdminUser(username) || fessLoginAssist.getSavedUserBean()
                        .map(user -> user.hasRoles(fessConfig.getAuthenticationAdminRolesAsArray()))
                        .orElse(false));

        runtime.registerData("pageLoginLink", fessConfig.isLoginLinkEnabled());

	if uni, ok := uniqueConstraints[name]; ok {
		return &uni, stmt.Table
	}

	getTable := func(rel *schema.Relationship) string {
		switch rel.Type {
		case schema.HasOne, schema.HasMany:
			return rel.FieldSchema.Table
		case schema.Many2Many:
			return rel.JoinTable.Table
		}
		return stmt.Table
	}

	for _, rel := range stmt.Schema.Relationships.Relations {

    public void processSearchPreference(final SearchRequestBuilder searchRequestBuilder, final OptionalThing<FessUserBean> userBean,
            final String query) {
        userBean.map(user -> {
            if (user.hasRoles(ComponentUtil.getFessConfig().getAuthenticationAdminRolesAsArray())) {
                return Constants.SEARCH_PREFERENCE_LOCAL;
            }
            return user.getUserId();

	}
	if got.Age != 30 {
		t.Fatalf("expected age 30, got %d", got.Age)
	}
	if len(got.Pets) != 1 || got.Pets[0].Name != "mix-pet" {
		t.Fatalf("expected pet created, got %+v", got.Pets)
	}
}

// HasOne unlink clears NamedPet
func TestClauseAssociationSetUpdateHasOneUnlink(t *testing.T) {
	ctx := context.Background()
	user := User{Name: "TestClauseAssociationSetUpdateHasOneUnlink", Age: 25}
	user.NamedPet = &Pet{Name: "np"}

		}
	}

	assocDB := s.c.g.db.Session(&Session{NewDB: true, Context: ctx}).Model(assocModel).Where(op.Conditions)

	switch rel.Type {
	case schema.HasOne, schema.HasMany:
		assocDB = assocDB.Where("? IN (?)", foreignColumns, base.Select(ownerPKNames))
		switch op.Type {
		case clause.OpUnlink:
			return assocDB.Updates(fkNil).Error
		case clause.OpDelete:

			if err != nil {
				return err
			}
		}
		var (
			ruleID  = fmt.Sprintf("site-repl-%s", d)
			hasRule bool
		)
		var ruleARN string
		for _, r := range replicationConfig.Rules {
			if r.ID == ruleID {
				hasRule = true
				ruleARN = r.Destination.Bucket
			}
		}

		ep, _ := url.Parse(peer.Endpoint)
		var targets []madmin.BucketTarget

            }
            final NamingEnumeration<SearchResult> results =
                    context.search(bindDn, "(name=" + escapeLDAPSearchFilter(groupName) + ")", searchControls);
            if (results.hasMore()) {
                final SearchResult searchResult = results.next();
                final Attribute attribute = searchResult.getAttributes().get("sAMAccountName");
                if (logger.isDebugEnabled()) {