package migrator

import "database/sql"

// Index implements gorm.Index interface
type Index struct {
	TableName       string
	NameValue       string
	ColumnList      []string
	PrimaryKeyValue sql.NullBool
	UniqueValue     sql.NullBool
	OptionValue     string
}

// Table return the table name of the index.
func (idx Index) Table() string {
	return idx.TableName
}

// Name return the name of the index.

	}
}

// TestSkipContentSha256Cksum - Test validate the logic which decides whether
// to skip checksum validation based on the request header.
func TestSkipContentSha256Cksum(t *testing.T) {
	testCases := []struct {
		inputHeaderKey   string
		inputHeaderValue string

		inputQueryKey   string
		inputQueryValue string

		expectedResult bool
	}{
		// Test case - 1.

package cmd

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[rebalanceMetricRebalanceBuckets-0]
	_ = x[rebalanceMetricRebalanceBucket-1]
	_ = x[rebalanceMetricRebalanceObject-2]
	_ = x[rebalanceMetricRebalanceRemoveObject-3]
	_ = x[rebalanceMetricSaveMetadata-4]
}

package clause

// From from clause
type From struct {
	Tables []Table
	Joins  []Join
}

// Name from clause name
func (from From) Name() string {
	return "FROM"
}

// Build build from clause
func (from From) Build(builder Builder) {
	if len(from.Tables) > 0 {
		for idx, table := range from.Tables {
			if idx > 0 {
				builder.WriteByte(',')
			}

			builder.WriteQuoted(table)
		}
	} else {

package clause_test

import (
	"fmt"
	"sort"
	"strings"
	"testing"

	"gorm.io/gorm/clause"
)

func TestSet(t *testing.T) {
	results := []struct {
		Clauses []clause.Interface
		Result  string
		Vars    []interface{}
	}{
		{
			[]clause.Interface{
				clause.Update{},
				clause.Set([]clause.Assignment{{clause.PrimaryColumn, 1}}),
			},
			"UPDATE `users` SET `users`.`id`=?",
			[]interface{}{1},
		},

	type CustomColumnAndIgnoredFieldClash struct {
		Body    string `gorm:"-"`
		RawBody string `gorm:"column:body"`
	}

	DB.Migrator().DropTable(&CustomColumnAndIgnoredFieldClash{})

	if err := DB.AutoMigrate(&CustomColumnAndIgnoredFieldClash{}); err != nil {
		t.Errorf("Should not raise error: %v", err)
	}
}

func TestCustomizeField(t *testing.T) {
	type CustomizeFieldStruct struct {
		gorm.Model

package cmd

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[formatUnknown-0]
	_ = x[formatGzip-1]
	_ = x[formatZstd-2]
	_ = x[formatLZ4-3]
	_ = x[formatS2-4]
	_ = x[formatBZ2-5]
}

const _format_name = "UnknownGzipZstdLZ4S2BZ2"

package tests_test

import (
	"context"
	"database/sql"
	"os"
	"reflect"
	"testing"

	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	. "gorm.io/gorm/utils/tests"
)

type wrapperTx struct {
	*sql.Tx
	conn *wrapperConnPool
}

func (c *wrapperTx) PrepareContext(ctx context.Context, query string) (*sql.Stmt, error) {
	c.conn.got = append(c.conn.got, query)
	return c.Tx.PrepareContext(ctx, query)
}

				switch db.Statement.ReflectValue.Kind() {
				case reflect.Struct:
					queryFields = db.Statement.ReflectValue.Type() != db.Statement.Schema.ModelType
				case reflect.Slice:
					queryFields = db.Statement.ReflectValue.Type().Elem() != db.Statement.Schema.ModelType
				}
			}

			if queryFields {
				stmt := gorm.Statement{DB: db}
				// smaller struct

package cmd

import "strconv"

func _() {
	// An "invalid array index" compiler error signifies that the constant values have changed.
	// Re-run the stringer command to generate them again.
	var x [1]struct{}
	_ = x[lcEventSrc_None-0]
	_ = x[lcEventSrc_Heal-1]
	_ = x[lcEventSrc_Scanner-2]
	_ = x[lcEventSrc_Decom-3]
	_ = x[lcEventSrc_Rebal-4]
	_ = x[lcEventSrc_s3HeadObject-5]
	_ = x[lcEventSrc_s3GetObject-6]