code: func SelectOne(m *DbMap, e SqlExecutor, holder interface{}, query string, args ...interface{}) error {
  	t := reflect.TypeOf(holder)
  	if t.Kind() == reflect.Ptr {
  		t = t.Elem()
  	} else {
  		return fmt.Errorf("gorp: SelectOne holder must be a pointer, but got: %t", holder)
  	}
  
  	// Handle pointer to pointer
  	isptr := false
  	if t.Kind() == reflect.Ptr {
  		isptr = true
  		t = t.Elem()
  	}
  
  	if t.Kind() == reflect.Struct {
  		var nonFatalErr error
  
  		list, err := hookedselect(m, e, holder, query, args...)
  		if err != nil {
  			if !NonFatalError(err) { // FIXME: double negative, rename NonFatalError to FatalError
  				return err
  			}
  			nonFatalErr = err
  		}
  
  		dest := reflect.ValueOf(holder)
  		if isptr {
  			dest = dest.Elem()
  		}
  
  		if list != nil && len(list) > 0 { // FIXME: invert if/else
  			// check for multiple rows
  			if len(list) > 1 {
  				return fmt.Errorf("gorp: multiple rows returned for: %s - %v", query, args)
  			}
  
  			// Initialize if nil
  			if dest.IsNil() {
  				dest.Set(reflect.New(t))
  			}
  
  			// only one row found
  			src := reflect.ValueOf(list[0])
  			dest.Elem().Set(src.Elem())
  		} else {
  			// No rows found, return a proper error.
  			return sql.ErrNoRows
  		}
  
  		return nonFatalErr
  	}
  
  	return selectVal(e, holder, query, args...)
  }
docs: // SelectOne executes the given query (which should be a SELECT statement)
  // and binds the result to holder, which must be a pointer.
  //
  // If no row is found, an error (sql.ErrNoRows specifically) will be returned
  //
  // If more than one row is found, an error will be returned.
  //