}

				for _, ref := range rel.References {
					updateMap[ref.ForeignKey.DBName] = nil
				}

				association.Error = association.DB.UpdateColumns(updateMap).Error
			}
			if association.Unscope && oldBelongsToExpr != nil {

		t.Fatalf("failed to onconflict create user, got error %v", err)
	} else {
		var user3 User
		DB.First(&user3, user.ID)
		if user3.UpdatedAt.UnixNano() == user2.UpdatedAt.UnixNano() {
			t.Fatalf("failed to update user's updated_at, old: %v, new: %v", user2.UpdatedAt, user3.UpdatedAt)
		}
	}
}

func TestUpsertSlice(t *testing.T) {
	langs := []Language{
		{Code: "upsert-slice1", Name: "Upsert-slice1"},

        this.createdAt = value;
    }

    public LocalDateTime getUpdatedAt() {
        checkSpecifiedProperty("updatedAt");
        return updatedAt;
    }

    public void setUpdatedAt(LocalDateTime value) {
        registerModifiedProperty("updatedAt");
        this.updatedAt = value;
    }

	UpdatedAt time.Time `json:"updatedAt"`
}

func newGroupInfo(members []string) GroupInfo {
	return GroupInfo{Version: 1, Status: statusEnabled, Members: members, UpdatedAt: UTCNow()}
}

// MappedPolicy represents a policy name mapped to a user or group
type MappedPolicy struct {
	Version   int       `json:"version"`
	Policies  string    `json:"policy"`
	UpdatedAt time.Time `json:"updatedAt"`
}

			}
		}
	case madmin.SRIAMItemSvcAcc:
		err = globalSiteReplicationSys.PeerSvcAccChangeHandler(ctx, item.SvcAccChange, item.UpdatedAt)
	case madmin.SRIAMItemPolicyMapping:
		err = globalSiteReplicationSys.PeerPolicyMappingHandler(ctx, item.PolicyMapping, item.UpdatedAt)
	case madmin.SRIAMItemSTSAcc:
		err = globalSiteReplicationSys.PeerSTSAccHandler(ctx, item.STSCredential, item.UpdatedAt)

					err = zb0002.Bins[zb0003].DecodeMsg(dc)
					if err != nil {
						err = msgp.WrapError(err, zb0001, "Bins", zb0003)
						return
					}
				}
			case "UpdatedAt":
				zb0002.UpdatedAt, err = dc.ReadTime()
				if err != nil {
					err = msgp.WrapError(err, zb0001, "UpdatedAt")
					return
				}
			default:
				err = dc.Skip()
				if err != nil {
					err = msgp.WrapError(err, zb0001)
					return
				}
			}
		}

    public void setUpdatedAt_Equal(LocalDateTime updatedAt) {
        setUpdatedAt_Term(updatedAt, null);
    }

    public void setUpdatedAt_Equal(LocalDateTime updatedAt, ConditionOptionCall<TermQueryBuilder> opLambda) {
        setUpdatedAt_Term(updatedAt, opLambda);
    }

    public void setUpdatedAt_Term(LocalDateTime updatedAt) {
        setUpdatedAt_Term(updatedAt, null);
    }

	if !sys.Initialized() {
		return updatedAt, errServerNotInitialized
	}

	if sys.usersSysType != MinIOUsersSysType {
		return updatedAt, errIAMActionNotAllowed
	}

	updatedAt, err = sys.store.SetUserStatus(ctx, accessKey, status)
	if err != nil {
		return updatedAt, err
	}

        setUpdatedAt_DateRange("updatedAt", opLambda, null);
    }

    public void setUpdatedAt_DateRange(ConditionOptionCall<DateRangeAggregationBuilder> opLambda, OperatorCall<BsUserInfoCA> aggsLambda) {
        setUpdatedAt_DateRange("updatedAt", opLambda, aggsLambda);
    }

		})
		if err != nil {
			return updatedAt, fmt.Errorf("Error encrypting bucket target metadata %w", err)
		}
		meta.BucketTargetsConfigUpdatedAt = updatedAt
		meta.BucketTargetsConfigMetaUpdatedAt = updatedAt
	default:
		return updatedAt, fmt.Errorf("Unknown bucket %s metadata update requested %s", bucket, configFile)
	}

	return updatedAt, sys.save(ctx, meta)
}