b.ResetTimer()
	for x := 0; x < b.N; x++ {
		DB.Raw("select * from users where id = ?", user.ID).Scan(&u)
	}
}

func BenchmarkScanSlice(b *testing.B) {
	DB.Exec("delete from users")
	for i := 0; i < 10_000; i++ {
		user := *GetUser(fmt.Sprintf("scan-%d", i), Config{})
		DB.Create(&user)
	}

	var u []User
	b.ResetTimer()
	for x := 0; x < b.N; x++ {
		DB.Raw("select * from users").Scan(&u)
	}
}

)

func shutdownHealMRFWithTimeout() {
	const shutdownTimeout = time.Minute

	finished := make(chan struct{})
	go func() {
		globalMRFState.shutdown()
		close(finished)
	}()
	select {
	case <-time.After(shutdownTimeout):
	case <-finished:
	}
}

func handleSignals() {
	// Custom exit function
	exit := func(success bool) {
		if globalLoggerOutput != nil {
			globalLoggerOutput.Close()

    def "latest patch version"() {
        given:
        def allVersions = ["2.0.30", "2.0.20", "2.0.10", "2.0.0"] + previousVersions

        when:
        def selected = UpdateKotlinVersions.selectVersionsFrom(minimumSupported, allVersions)

        then:
        selected == ["1.9.10", "1.9.25", "2.0.30"]
    }

    def "beta of latest patch version"() {
        given:
        def allVersions = [

	user := User{Name: "jinzhu"}

	DB.Create(&user)

	subQuery := DB.Table("users").Where("name=?", user.Name).Select("id")

	result := DB.Session(&gorm.Session{DryRun: true}).Model(&Pet{}).Create([]map[string]interface{}{
		{
			"name":    "cat",
			"user_id": gorm.Expr("(?)", DB.Table("(?) as tmp", subQuery).Select("@uid:=id")),
		},
		{
			"name":    "dog",
			"user_id": gorm.Expr("@uid"),
		},
	})

      description: What actually happened?
    validations:
      required: true

  - type: dropdown
    attributes:
      label: Packages
      description: If this issue is package-specific, then please select the relevant packages.
      multiple: true
      options:
        - com.google.common.annotations
        - com.google.common.base
        - com.google.common.cache
        - com.google.common.collect

		return fmt.Errorf("Select parameters can only be specified with SELECT request type")
	}
	if r.Type == SelectRestoreRequest && r.SelectParameters.IsEmpty() {
		return fmt.Errorf("SELECT restore request requires select parameters to be specified")
	}

	if r.Type != SelectRestoreRequest && !r.OutputLocation.IsEmpty() {
		return fmt.Errorf("OutputLocation required only for SELECT request type")
	}

func BenchmarkSelectAll_10M(b *testing.B) {
	benchmarkSelectAll(b, 10*humanize.MiByte)
}

func benchmarkSingleCol(b *testing.B, count int) {
	benchmarkSelect(b, count, "select id from S3Object")
}

// BenchmarkSingleRow_100K - benchmark SELECT column function with 100k records.
func BenchmarkSingleCol_100K(b *testing.B) {
	benchmarkSingleCol(b, 1e5)
}

// BenchmarkSelectAll_1M - benchmark * function with 1m records.

                select(CommonBuilds.PROJECT_PATH_TEST, CommonBuilds.BUILD_PATH_COMPILE),
                Collections.singletonList(system),
                nonTransitiveDependencyScopes));
        result.add(internalScopeManager.createResolutionScope(
                RS_TEST_RUNTIME,
                InternalScopeManager.Mode.ELIMINATE,

     * <code>maven-toolchains-plugin</code> contains the configuration to select the appropriate
     * toolchain and is executed at the beginning of the build.
     *
     * @param type the type, must not be {@code null}
     * @param context the Maven session, must not be {@code null}
     * @return the toolchain selected by <code>maven-toolchains-plugin</code>
     */

	// Translate doubled quotes
	*qi = QuotedIdentifier(strings.ReplaceAll(r, `""`, `"`))
	return nil
}

// Types representing AST of SQL statement. Only SELECT is supported.

// Select is the top level AST node type
type Select struct {
	Expression *SelectExpression `parser:"\"SELECT\" @@"`
	From       *TableExpression  `parser:"\"FROM\" @@"`
	Where      *Expression       `parser:"( \"WHERE\" @@ )?"`