writes := make([]uint64, len(infos))
	for index, di := range infos {
		deletes[index] = di.Metrics.TotalDeletes
		writes[index] = di.Metrics.TotalWrites
	}

	filter := func(list []uint64) (commonCount uint64) {
		maxCnt := 0
		signatureMap := map[uint64]int{}
		for _, v := range list {
			signatureMap[v]++
		}
		for ops, count := range signatureMap {
			if maxCnt < count && commonCount < ops {

		}
		for i, w := range writers {
			if w == nil {
				disks[i] = OfflineDisk
			}
		}
		if err == nil {
			if length := int64(len(data[test.offset:])); n != length {
				t.Errorf("Test %d: invalid number of bytes written: got: #%d want #%d", i, n, length)
			}
			writers := make([]io.Writer, len(disks))
			for i, disk := range disks {
				if disk == nil {
					continue
				}

	<-serverSent

	// Now do 100 other requests to ensure that the server doesn't block.
	for range 100 {
		_, err := remoteConn.Request(ctx, handlerTest2, []byte(testPayload))
		errFatal(err)
	}
	// Drain responses
	got := 0
	for resp := range st.responses {
		// t.Log("got response", resp)
		errFatal(resp.Err)
		if resp.Msg[0] != byte(got) {

		err = msgp.WrapError(err)
		return
	}
	for za0001 := range z {
		// map header, size 2
		// write "Totals"
		err = en.Append(0x82, 0xa6, 0x54, 0x6f, 0x74, 0x61, 0x6c, 0x73)
		if err != nil {
			return
		}
		err = en.WriteArrayHeader(uint32(60))
		if err != nil {
			err = msgp.WrapError(err, za0001, "Totals")
			return
		}
		for za0002 := range z[za0001].Totals {
			// map header, size 3

		{NewTargetIDSet(TargetID{"1", "webhook"}), TargetID{"2", "webhook"}},
		{NewTargetIDSet(TargetID{"1", "webhook"}, TargetID{"2", "amqp"}), TargetID{"2", "webhook"}},
	}

	for i, testCase := range testCases {
		result := testCase.set.Clone()

		if !reflect.DeepEqual(result, testCase.set) {
			t.Fatalf("test %v: result: expected: %v, got: %v", i+1, testCase.set, result)
		}

		result.add(testCase.targetIDToAdd)

	if err != nil {
		err = msgp.WrapError(err)
		return
	}
	for zb0006, zb0007 := range z {
		err = en.WriteString(zb0006)
		if err != nil {
			err = msgp.WrapError(err)
			return
		}
		err = en.WriteArrayHeader(uint32(len(zb0007)))
		if err != nil {
			err = msgp.WrapError(err, zb0006)
			return
		}
		for zb0008 := range zb0007 {
			err = zb0007[zb0008].EncodeMsg(en)
			if err != nil {

					return tx
				}

				refColumns := []clause.Column{}
				for _, rel := range relation.References {
					if rel.OwnPrimaryKey {
						refColumns = append(refColumns, clause.Column{Name: rel.ForeignKey.DBName})
					}
				}

				if len(refColumns) != 0 {
					selectExpr := clause.CommaExpression{}
					for _, column := range q.db.Statement.Selects {

				}
			} else {
				for _, t := range convertibleTypes {
					if rv.Type().ConvertibleTo(t) {
						convertParams(rv.Convert(t).Interface(), idx)
						return
					}
				}
				vars[idx] = escaper + strings.ReplaceAll(fmt.Sprint(v), escaper, escaper+escaper) + escaper
			}
		}
	}

	for idx, v := range avars {
		convertParams(v, idx)
	}

func (values Values) Build(builder Builder) {
	if len(values.Columns) > 0 {
		builder.WriteByte('(')
		for idx, column := range values.Columns {
			if idx > 0 {
				builder.WriteByte(',')
			}
			builder.WriteQuoted(column)
		}
		builder.WriteByte(')')

		builder.WriteString(" VALUES ")

		for idx, value := range values.Values {
			if idx > 0 {
				builder.WriteByte(',')
			}

			builder.WriteByte('(')

		{Name: "ManagerID", DBName: "manager_id", BindNames: []string{"ManagerID"}, DataType: schema.Uint, Size: 64},
		{Name: "Active", DBName: "active", BindNames: []string{"Active"}, DataType: schema.Bool},
	}

	for i := range fields {
		checkSchemaField(t, user, &fields[i], func(f *schema.Field) {
			f.Creatable = true
			f.Updatable = true
			f.Readable = true
		})
	}

	// check relations
	relations := []Relation{
		{