"9.1.1 OK"
"9.1.2 OK"
"9.1.3 OK"
"9.1.4 OK"
"9.1.5 OK"
"9.1.6 OK"
"9.2.1 OK"
"9.2.2 OK"
"9.2.3 OK"
"9.2.4 OK"
"9.2.5 OK"
"9.2.6 OK"
"9.3.1 OK"
"9.3.2 OK"
"9.3.3 OK"
"9.3.4 OK"
"9.3.5 OK"
"9.3.6 OK"
"9.3.7 OK"
"9.3.8 OK"
"9.3.9 OK"
"9.4.1 OK"
"9.4.2 OK"
"9.4.3 OK"
"9.4.4 OK"
"9.4.5 OK"
"9.4.6 OK"
"9.4.7 OK"
"9.4.8 OK"
"9.4.9 OK"
"9.5.1 OK"

							assignValue(field, value[k])
						}
					} else if v, ok := selectColumns[field.Name]; (ok && v) || (!ok && !restricted) {
						assignValue(field, value[k])
					}
					continue
				}
			}

			if v, ok := selectColumns[k]; (ok && v) || (!ok && !restricted) {
				set = append(set, clause.Assignment{Column: clause.Column{Name: k}, Value: kv})
			}
		}

		if !stmt.SkipHooks && stmt.Schema != nil {

func (where Where) Build(builder Builder) {
	if len(where.Exprs) == 1 {
		if andCondition, ok := where.Exprs[0].(AndConditions); ok {
			where.Exprs = andCondition.Exprs
		}
	}

	// Switch position if the first query expression is a single Or condition
	for idx, expr := range where.Exprs {
		if v, ok := expr.(OrConditions); !ok || len(v.Exprs) > 1 {
			if idx != 0 {

	createCallback.Remove("c1")
	if ok, msg := assertCallbacks(createCallback, []string{"c3", "c4", "c2"}); !ok {
		t.Errorf("callbacks tests failed, got %v", msg)
	}

	createCallback.Remove("c4")
	if ok, msg := assertCallbacks(createCallback, []string{"c3", "c2"}); !ok {
		t.Errorf("callbacks tests failed, got %v", msg)
	}

	createCallback.Remove("c2")

			if inName {
				if nv, ok := namedMap[string(name)]; ok {
					builder.AddVar(builder, nv)
				} else {
					builder.WriteByte('@')
					builder.WriteString(string(name))
				}
				inName = false
			}

			afterParenthesis = false
			builder.WriteByte(v)
		} else if v == '?' && len(expr.Vars) > idx {
			if afterParenthesis {
				if _, ok := expr.Vars[idx].(driver.Valuer); ok {

}

// ColumnType returns the database type of the column. like `varchar(16)`
func (ct ColumnType) ColumnType() (columnType string, ok bool) {
	return ct.ColumnTypeValue.String, ct.ColumnTypeValue.Valid
}

// PrimaryKey returns the column is primary key or not.
func (ct ColumnType) PrimaryKey() (isPrimaryKey bool, ok bool) {
	return ct.PrimaryKeyValue.Bool, ct.PrimaryKeyValue.Valid
}

    assertInvalid("HTTP/2.1 200 OK")
    assertInvalid("HTTP/-.1 200 OK")
    assertInvalid("HTTP/1.- 200 OK")
    assertInvalid("HTTP/0.1 200 OK")
    assertInvalid("HTTP/101 200 OK")
    assertInvalid("HTTP/1.1_200 OK")
  }

  @Test
  fun nonThreeDigitCode() {
    assertInvalid("HTTP/1.1  OK")
    assertInvalid("HTTP/1.1 2 OK")
    assertInvalid("HTTP/1.1 20 OK")
    assertInvalid("HTTP/1.1 2000 OK")

	ColumnType() (columnType string, ok bool) // varchar(64)
	PrimaryKey() (isPrimaryKey bool, ok bool)
	AutoIncrement() (isAutoIncrement bool, ok bool)
	Length() (length int64, ok bool)
	DecimalSize() (precision int64, scale int64, ok bool)
	Nullable() (nullable bool, ok bool)
	Unique() (unique bool, ok bool)
	ScanType() reflect.Type
	Comment() (value string, ok bool)
	DefaultValue() (value string, ok bool)
}

func (a BitrotAlgorithm) Available() bool {
	_, ok := bitrotAlgorithms[a]
	return ok
}

// String returns the string identifier for a given bitrot algorithm.
// If the algorithm is not supported String panics.
func (a BitrotAlgorithm) String() string {
	name, ok := bitrotAlgorithms[a]
	if !ok {
		logger.CriticalIf(GlobalContext, errors.New("Unsupported bitrot algorithm"))
	}
	return name

	yval := reflect.ValueOf(y)
	if xval.Kind() == reflect.Ptr && xval.IsNil() ||
		yval.Kind() == reflect.Ptr && yval.IsNil() {
		return false
	}

	if valuer, ok := x.(driver.Valuer); ok {
		x, _ = valuer.Value()
	}
	if valuer, ok := y.(driver.Valuer); ok {
		y, _ = valuer.Value()
	}
	return reflect.DeepEqual(x, y)
}

func ToString(value interface{}) string {
	switch v := value.(type) {
	case string: