Golang exit a loop based on seconds

I'm trying to execute sql query in a loop and the loop needs to exit 5 seconds is elapsed and also need to exit, if the iteration is complete.

startTime := time.Now()
	for _, index := range indices {
		elapsedTime := time.Since(startTime)

		if elapsedTime.Seconds() >= 5 {
			break
		}
		// sql query execution
	} 

is there any better approach for this?

Ignoring for a second the apparent X-Y problem at play here, breaking out of a loop after 5 seconds is trivial to do:

You can just use a time interval and a select for something like this:

timer := time.NewTimer(5 * time.Second)
defer timer.Stop() // always clean up
for _, i := range indeces {
    select {
    case <-timer.C():
        // timer has expired
        return // done
    default:
       // do whatever you want the loop to do
    }
}

Easy. To ensure queries aren't executed after the 5 second period has elapsed, you can also use a context with timeout, and pass said context to all SQL related calls:

ctx, cfunc := context.WithTimeout(context.Background(), 5 * time.Second)
defer cfunc() // again, always clean up after yourself

The rest of the loop will look pretty much the same:

for _, i := range indeces {
    select {
    case <-ctx.Done():
        return
    default:
       // do whatever
    }
}

X-Y problem

Now circling back to the X-Y problem here: I'm not sure whether implementing a hard time limit is the solution to your problem. Why are you iterating over a slice named "indeces", which in turn results in an arbitrary number of queries being executed over an extended period of time, and, as you mentioned in comments, why are all these queries different to begin with? What is this loop supposed to do? What are you trying to implement. There's a close to 100% guarantee that what you have is a problem that shouldn't be solved, but instead can be easily avoided (hence, you're asking how do to Y, whereas the real question is why you did X that causes you to now looking for a way to do Y)

Are you asking about something like using a context that times out after 5 seconds? Depending on your implementation, you could pass the context to your sql query func or simply return from the routine when the context times out. A rough outline might look something like this.

ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()

_, err := db.ExecContext(ctx, "SELECT ...")