doc := &model.Table{Title: "table"}
err := db.Table("table").Clauses(clause.OnConflict{UpdateAll: true}).Create(&doc).Error

type OnConflict struct {
	Columns      []Column
	Where        Where
	TargetWhere  Where
	OnConstraint string
	DoNothing    bool
	DoUpdates    Set
	UpdateAll    bool
}

if !db.DryRun && db.Error == nil {
	result, err := db.Statement.ConnPool.ExecContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)

	if err == nil {
		db.RowsAffected, _ = result.RowsAffected()

		if db.RowsAffected > 0 {
			if db.Statement.Schema != nil && db.Statement.Schema.PrioritizedPrimaryField != nil && db.Statement.Schema.PrioritizedPrimaryField.HasDefaultValue {
				if insertID, err := result.LastInsertId(); err == nil && insertID > 0 {
					switch db.Statement.ReflectValue.Kind() {
					case reflect.Slice, reflect.Array:
						if config.LastInsertIDReversed {
							for i := db.Statement.ReflectValue.Len() - 1; i >= 0; i-- {
								rv := db.Statement.ReflectValue.Index(i)
								if reflect.Indirect(rv).Kind() != reflect.Struct {
									break
								}

								_, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(rv)
								if isZero {
									db.Statement.Schema.PrioritizedPrimaryField.Set(rv, insertID)
									insertID -= db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement
								}
							}
						} else {
							for i := 0; i < db.Statement.ReflectValue.Len(); i++ {
								rv := db.Statement.ReflectValue.Index(i)
								if reflect.Indirect(rv).Kind() != reflect.Struct {
									break
								}

								if _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(rv); isZero {
									db.Statement.Schema.PrioritizedPrimaryField.Set(rv, insertID)
									insertID += db.Statement.Schema.PrioritizedPrimaryField.AutoIncrementIncrement
								}
							}
						}
					case reflect.Struct:
						if _, isZero := db.Statement.Schema.PrioritizedPrimaryField.ValueOf(db.Statement.ReflectValue); isZero {
							db.Statement.Schema.PrioritizedPrimaryField.Set(db.Statement.ReflectValue, insertID)
						}
					}
				} else {
					db.AddError(err)
				}
			}
		}
	} else {
		db.AddError(err)
	}
}

package main

// Import necessary packages
import (
	"context"
	"crypto/tls"
	"fmt"
	"net"
	"net/http"
	"time"

	"github.com/prometheus/client_golang/api"
	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
	"github.com/prometheus/common/model"
)

// BasicAuthRoundTripper is a RoundTripper that adds basic authentication credentials to requests
type BasicAuthRoundTripper struct {
	Username     string
	Password     string
	RoundTripper http.RoundTripper
}

func (rt *BasicAuthRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
	req.SetBasicAuth(rt.Username, rt.Password)
	return rt.RoundTripper.RoundTrip(req)
}

// Define a struct to hold the query results
type QueryResult struct {
	Metric model.Metric      `json:"metric"`
	Value  model.SampleValue `json:"value"`
}

// Define a function to query Prometheus with a given username, password
func QueryPrometheus(username string, password string, query string) ([]QueryResult, error) {
	// Create a new HTTP client with the given username and password
	client, err := api.NewClient(api.Config{
		Address: "http://localhost:9090",
		RoundTripper: &BasicAuthRoundTripper{
			Username: username,
			Password: password,
			RoundTripper: &http.Transport{
				Proxy:           http.ProxyFromEnvironment,
				TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
				// Set the username and password for basic authentication
				// Note: this is not secure and should not be used in production
				// Instead, use a secure authentication method such as OAuth2
				// or a reverse proxy with authentication
				DialContext: (&net.Dialer{
					Timeout:   30 * time.Second,
					KeepAlive: 30 * time.Second,
				}).DialContext,
				ForceAttemptHTTP2:     true,
				MaxIdleConns:          100,
				IdleConnTimeout:       90 * time.Second,
				TLSHandshakeTimeout:   10 * time.Second,
				ExpectContinueTimeout: 1 * time.Second,
				ProxyConnectHeader:    http.Header{},
			},
		},
	})
	if err != nil {
		return nil, err
	}

	// Create a new Prometheus API client
	prometheusClient := v1.NewAPI(client)

	// Query Prometheus with the built query string
	result, warnings, err := prometheusClient.Query(context.Background(), query, time.Now())
	if err != nil {
		return nil, err
	}
	if len(warnings) > 0 {
		fmt.Println("Warnings:", warnings)
	}

	// Parse the query result into a slice of QueryResult structs
	var queryResults []QueryResult
	for _, res := range result.(model.Vector) {
		queryResults = append(queryResults, QueryResult{
			Metric: res.Metric,
			Value:  res.Value,
		})
	}

	return queryResults, nil
}

package main

// Import necessary packages
import (
	"context"
	"crypto/tls"
	"fmt"
	"net"
	"net/http"
	"time"

	"github.com/prometheus/client_golang/api"
	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
	"github.com/prometheus/common/model"
)

// BasicAuthRoundTripper is a RoundTripper that adds basic authentication credentials to requests
type BasicAuthRoundTripper struct {
	Username     string
	Password     string
	RoundTripper http.RoundTripper
}

func (rt *BasicAuthRoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
	req.SetBasicAuth(rt.Username, rt.Password)
	return rt.RoundTripper.RoundTrip(req)
}

// Define a struct to hold the query results
type QueryResult struct {
	Metric model.Metric      `json:"metric"`
	Value  model.SampleValue `json:"value"`
}

// Define a function to query Prometheus with a given username, password, and label
func QueryPrometheus(username string, password string, my_metric string, key string, value string) ([]QueryResult, error) {
	// Create a new HTTP client with the given username and password
	client, err := api.NewClient(api.Config{
		Address: "http://localhost:9090",
		RoundTripper: &BasicAuthRoundTripper{
			Username: username,
			Password: password,
			RoundTripper: &http.Transport{
				Proxy:           http.ProxyFromEnvironment,
				TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
				// Set the username and password for basic authentication
				// Note: this is not secure and should not be used in production
				// Instead, use a secure authentication method such as OAuth2
				// or a reverse proxy with authentication
				DialContext: (&net.Dialer{
					Timeout:   30 * time.Second,
					KeepAlive: 30 * time.Second,
				}).DialContext,
				ForceAttemptHTTP2:     true,
				MaxIdleConns:          100,
				IdleConnTimeout:       90 * time.Second,
				TLSHandshakeTimeout:   10 * time.Second,
				ExpectContinueTimeout: 1 * time.Second,
				ProxyConnectHeader:    http.Header{},
			},
		},
	})
	if err != nil {
		return nil, err
	}

	// Create a new Prometheus API client
	prometheusClient := v1.NewAPI(client)

	// Build the query string with the given label
	query := fmt.Sprintf(`%s{%s="%s"}`, my_metric, key, value)

	// Query Prometheus with the built query string
	result, warnings, err := prometheusClient.Query(context.Background(), query, time.Now())
	if err != nil {
		return nil, err
	}
	if len(warnings) > 0 {
		fmt.Println("Warnings:", warnings)
	}

	// Parse the query result into a slice of QueryResult structs
	var queryResults []QueryResult
	for _, res := range result.(model.Vector) {
		queryResults = append(queryResults, QueryResult{
			Metric: res.Metric,
			Value:  res.Value,
		})
	}

	return queryResults, nil
}

package main

import (
	"context"
	"encoding/json"
	"sync"
	"testing"

	"github.com/stretchr/testify/assert"
)

type Class struct {
	Id      int64      `json:"id"`
	Name    string     `json:"name"`
	Grade   string     `json:"grade"`
	Student []*Student `json:"student"`
}

type Student struct {
	Id      int64  `json:"id"`
	ClassId int64  `json:"classId"`
	Name    string `json:"name"`
}

func TestWaitGroup(t *testing.T) {
	var (
		mu       sync.Mutex
		wg       = sync.WaitGroup{}
		errs     = make([]error, 0)
		classArr = []*Class{{Id: 1}, {Id: 2}, {Id: 3}}
	)

	wg.Add(len(classArr))
	for _, item := range classArr {
		go func(class *Class) {
			defer wg.Done()
			ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
			defer cancel()
			students, err := queryAllStudent(ctx, class.Id)
			if err != nil {
				mu.Lock()
				errs = append(errs, err)
				mu.Unlock()
				return
			}
			class.Student = students
		}(item)
	}
	wg.Wait()
	assert.Equal(t, len(errs), 0)

	bytes, err := json.Marshal(classArr)
	assert.Nil(t, err)

	t.Log(string(bytes))
}

func queryAllStudent(ctx context.Context, classId int64) ([]*Student, error) {
	return map[int64][]*Student{
		1: []*Student{{Id: 1}, {Id: 2}, {Id: 3}},
		2: []*Student{{Id: 4}, {Id: 5}, {Id: 6}},
		3: []*Student{{Id: 7}, {Id: 8}, {Id: 9}},
	}[classId], nil
}

if len(req.FirstName) == 0 {
	msg.Code = ErrFirstNameIsRequired
	return
}
if len(req.LastName) == 0 {
	msg.Code = ErrLastNameIsRequired
	return
}
if len(req.Address) == 0 {
	msg.Code = ErrAddressIsRequired
	return
}
if len(req.PostalCode) == 0 {
	msg.Code = ErrPostalCodeIsRequired
	return
}
if len(req.City) == 0 {
	msg.Code = ErrCityIsRequired
	return
}

// ValidateString 字符串验证结构
type ValidateString struct {
    Str  string
    Code int
}

// ValidateEmptyString 验证字符串是否为空
func ValidateEmptyString(s []*ValidateString) (code int, empty bool) {
    for _, v := range s {
        if len(v.Str) == 0 {
            empty = true
            code = v.Code
            return
        }
	}
    return
}