func (q QueryExecutor) ScanStructContext(ctx context.Context, i interface{}) (bool, error) {
	val := reflect.ValueOf(i)
	if !util.IsPointer(val.Kind()) {
		return false, errUnsupportedScanStructType
	}
	val = reflect.Indirect(val)
	if !util.IsStruct(val.Kind()) {
		return false, errUnsupportedScanStructType
	}
	scanner, err := q.ScannerContext(ctx)
	if err != nil {
		return false, err
	}
	defer func() { _ = scanner.Close() }()
	if scanner.Next() {
		err = scanner.ScanStruct(i)
		if err != nil {
			return false, err
		}
		return true, scanner.Err()
	}
	return false, scanner.Err()
}
This will execute the SQL and fill out the struct with the fields returned.
This method returns a boolean value that is false if no record was found
var myStruct MyStruct
found, err := db.From("test").Limit(1).ScanStructContext(ctx, &myStruct)
if err != nil{
panic(err.Error()
}
if !found{
fmt.Println("NOT FOUND")
}

i: A pointer to a struct
package exec
import (
	"context"
	gsql "database/sql"
	"reflect"
	"github.com/doug-martin/goqu/v9/internal/errors"
	"github.com/doug-martin/goqu/v9/internal/util"
)
type (
	QueryExecutor struct {
		de    DbExecutor
		err   error
		query string
		args  []interface{}
	}
)
var (
	errUnsupportedScanStructType  = errors.New("type must be a pointer to a struct when scanning into a struct")
	errUnsupportedScanStructsType = errors.New("type must be a pointer to a slice when scanning into structs")
	errUnsupportedScanValsType    = errors.New("type must be a pointer to a slice when scanning into vals")
	errScanValPointer             = errors.New("type must be a pointer when scanning into val")
	errScanValNonSlice            = errors.New("type cannot be a pointer to a slice when scanning into val")
)
func newQueryExecutor(de DbExecutor, err error, query string, args ...interface{}) QueryExecutor {
	return QueryExecutor{de: de, err: err, query: query, args: args}
}
func (q QueryExecutor) ToSQL() (sql string, args []interface{}, err error) {
	return q.query, q.args, q.err
}
func (q QueryExecutor) Exec() (gsql.Result, error) {
	return q.ExecContext(context.Background())
}
func (q QueryExecutor) ExecContext(ctx context.Context) (gsql.Result, error) {
	if q.err != nil {
		return nil, q.err
	}
	return q.de.ExecContext(ctx, q.query, q.args...)
}
func (q QueryExecutor) Query() (*gsql.Rows, error) {
	return q.QueryContext(context.Background())
}
func (q QueryExecutor) QueryContext(ctx context.Context) (*gsql.Rows, error) {
	if q.err != nil {
		return nil, q.err
	}
	return q.de.QueryContext(ctx, q.query, q.args...)
}
func (q QueryExecutor) ScanStructs(i interface{}) error {
	return q.ScanStructsContext(context.Background(), i)
}
func (q QueryExecutor) ScanStructsContext(ctx context.Context, i interface{}) error {
	scanner, err := q.ScannerContext(ctx)
	if err != nil {
		return err
	}
	defer func() { _ = scanner.Close() }()
	return scanner.ScanStructs(i)
}
func (q QueryExecutor) ScanStruct(i interface{}) (bool, error) {
	return q.ScanStructContext(context.Background(), i)
}