import org.jspecify.annotations.Nullable;

/**
 * Implementation of {@code Table} whose iteration ordering across row keys is sorted by their
 * natural ordering or by a supplied comparator. Note that iterations across the columns keys for a
 * single row key may or may not be ordered, depending on the implementation. When rows and columns
 * are both sorted, it's easier to use the {@link TreeBasedTable} subclass.
 *

	case aggFnMin:
		if !e.aggregate.seen {
			// No rows were seen by MIN
			return FromNull(), nil
		}
		return e.aggregate.runningMin, nil

	case aggFnMax:
		if !e.aggregate.seen {
			// No rows were seen by MAX
			return FromNull(), nil
		}
		return e.aggregate.runningMax, nil

	case aggFnSum:
		// TODO: check if returning 0 when no rows were seen
		// by SUM is expected behavior.

	DB.Save(&user1).Save(&user2).Save(&user3)

	rows, err := DB.Table("users").Where("name = ? or name = ?", user2.Name, user3.Name).Select("name, age").Rows()
	if err != nil {
		t.Errorf("No error should happen, got %v", err)
	}

	type Result struct {
		Name string
		Age  int
	}

	var results []Result
	for rows.Next() {
		var result Result
		if err := DB.ScanRows(rows, &result); err != nil {

                                                     styleClass="form-control" rows="5"/>
                                    </div>
                                </div>
                                <div class="form-group row">
                                    <label for="excludedPaths" class="col-sm-3 text-sm-right col-form-label"><la:message

pkg database/sql, method (*DB) QueryContext(context.Context, string, ...interface{}) (*Rows, error)
pkg database/sql, method (*DB) QueryRowContext(context.Context, string, ...interface{}) *Row
pkg database/sql, method (*Rows) ColumnTypes() ([]*ColumnType, error)
pkg database/sql, method (*Rows) NextResultSet() bool
pkg database/sql, method (*Stmt) ExecContext(context.Context, ...interface{}) (Result, error)

                                                     rows="5"/>
                                    </div>
                                </div>
                                <div class="form-group row">
                                    <label for="boostExpr" class="col-sm-3 text-sm-right col-form-label"><la:message

	if res.Error != nil || res.RowsAffected != 1 {
		t.Fatalf("first or create rows affect err:%v rows:%d", res.Error, res.RowsAffected)
	}

	res = DB.FirstOrCreate(&user, "name = ?", user.Name)
	if res.Error != nil || res.RowsAffected != 0 {
		t.Fatalf("first or create rows affect err:%v rows:%d", res.Error, res.RowsAffected)
	}
}

func TestCreateWithAutoIncrementCompositeKey(t *testing.T) {

	if db.Error == nil {
		BuildQuerySQL(db)

		if !db.DryRun && db.Error == nil {
			rows, err := db.Statement.ConnPool.QueryContext(db.Statement.Context, db.Statement.SQL.String(), db.Statement.Vars...)
			if err != nil {
				db.AddError(err)
				return
			}
			defer func() {
				db.AddError(rows.Close())
			}()
			gorm.Scan(rows, db, 0)

			if db.Statement.Result != nil {

        }
    }

    /**
     * Executes the update.
     *
     * @param ps
     *            {@link PreparedStatement}. Must not be {@literal null}.
     * @return The number of rows affected by the update.
     * @throws SQLRuntimeException
     *             If a {@link SQLException} occurs.
     */
    public static int executeUpdate(final PreparedStatement ps) throws SQLRuntimeException {

		t.Fatalf("Failed, got error: %v, rows affected: %v", result.Error, result.RowsAffected)
	}

	tx2 := db.Begin()
	if result := tx2.Where("name=?", "zzjin").Delete(&User{}); result.Error != nil || result.RowsAffected != 0 {
		t.Fatalf("Failed, got error: %v, rows affected: %v", result.Error, result.RowsAffected)
	}
	tx2.Commit()
}