func (r *Rows) GetStringSlice(row, column int) ([]string, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return nil, err
	}
	res, err := common.ConvertToSlice(value, reflect.String)
	if err != nil {
		return nil, err
	}
	return res.([]string), nil
}
GetStringSlice returns []string type value of given row and column number
package result
import (
	"database/sql/driver"
	"fmt"
	"reflect"
	"github.com/pkg/errors"
	"github.com/romberli/go-util/common"
	"github.com/romberli/go-util/constant"
)
const mapColumnNum = 2
type Rows struct {
	FieldSlice []string
	FieldMap   map[string]int
	Values     [][]driver.Value
}
func NewRows(fieldSlice []string, fieldMap map[string]int, values [][]driver.Value) *Rows {
	return &Rows{
		fieldSlice,
		fieldMap,
		values,
	}
}
func NewRowsWithRows(rows driver.Rows) *Rows {
	var values [][]driver.Value
	columns := rows.Columns()
	fieldMap := make(map[string]int)
	for i, column := range columns {
		fieldMap[column] = i
	}
	row := make([]driver.Value, len(columns))
	for rows.Next(row) == nil {
		r := make([]driver.Value, len(columns))
		_ = copy(r, row)
		values = append(values, r)
	}
	return &Rows{
		columns,
		fieldMap,
		values,
	}
}
func NewEmptyRows() *Rows {
	return &Rows{}
}
func (r *Rows) RowNumber() int {
	return len(r.Values)
}
func (r *Rows) ColumnNumber() int {
	return len(r.FieldSlice)
}
func (r *Rows) GetValue(row, column int) (interface{}, error) {
	if row >= len(r.Values) || row < constant.ZeroInt {
		return nil, errors.Errorf("invalid row index %d", row)
	}
	if column >= len(r.FieldSlice) || column < constant.ZeroInt {
		return nil, errors.Errorf("invalid column index %d", column)
	}
	return r.Values[row][column], nil
}
func (r *Rows) ColumnExists(name string) bool {
	_, ok := r.FieldMap[name]
	return ok
}
func (r *Rows) NameIndex(name string) (int, error) {
	column, ok := r.FieldMap[name]
	if ok {
		return column, nil
	}
	return constant.ZeroInt, errors.Errorf("invalid field name %s", name)
}
func (r *Rows) GetValueByName(row int, name string) (interface{}, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return nil, err
	}
	return r.GetValue(row, column)
}
func (r *Rows) IsNull(row, column int) (bool, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return false, err
	}
	return value == nil, nil
}
func (r *Rows) IsNullByName(row int, name string) (bool, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return false, err
	}
	return r.IsNull(row, column)
}
func (r *Rows) GetUint(row, column int) (uint, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return constant.ZeroInt, err
	}
	return common.ConvertToUint(value)
}
func (r *Rows) GetUintByName(row int, name string) (uint, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return constant.ZeroInt, err
	}
	return r.GetUint(row, column)
}
func (r *Rows) GetInt(row, column int) (int, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return constant.ZeroInt, err
	}
	return common.ConvertToInt(value)
}
func (r *Rows) GetIntByName(row int, name string) (int, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return constant.ZeroInt, err
	}
	return r.GetInt(row, column)
}
func (r *Rows) GetFloat(row, column int) (float64, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return constant.ZeroInt, err
	}
	return common.ConvertToFloat(value)
}
func (r *Rows) GetFloatByName(row int, name string) (float64, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return constant.ZeroInt, err
	}
	return r.GetFloat(row, column)
}
func (r *Rows) GetString(row, column int) (string, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return constant.EmptyString, err
	}
	return common.ConvertToString(value)
}
func (r *Rows) GetStringByName(row int, name string) (string, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return constant.EmptyString, err
	}
	return r.GetString(row, column)
}
func (r *Rows) GetSlice(row, column int) ([]interface{}, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return nil, err
	}
	valueKind := reflect.TypeOf(value).Kind()
	if valueKind != reflect.Slice {
		return nil, errors.New(fmt.Sprintf("value must be a slice, not %s", valueKind.String()))
	}
	valueOf := reflect.ValueOf(value)
	v := make([]interface{}, valueOf.Len())
	for i := 0; i < valueOf.Len(); i++ {
		v[i] = valueOf.Index(i).Interface()
	}
	return v, nil
}
func (r *Rows) GetSliceByName(row int, name string) ([]interface{}, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return nil, err
	}
	return r.GetSlice(row, column)
}
func (r *Rows) GetUintSlice(row, column int) ([]uint, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return nil, err
	}
	res, err := common.ConvertToSlice(value, reflect.Uint)
	if err != nil {
		return nil, err
	}
	return res.([]uint), nil
}
func (r *Rows) GetUintSliceByName(row int, name string) ([]uint, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return nil, err
	}
	return r.GetUintSlice(row, column)
}
func (r *Rows) GetIntSlice(row, column int) ([]int, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return nil, err
	}
	res, err := common.ConvertToSlice(value, reflect.Int)
	if err != nil {
		return nil, err
	}
	return res.([]int), nil
}
func (r *Rows) GetIntSliceByName(row int, name string) ([]int, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return nil, err
	}
	return r.GetIntSlice(row, column)
}
func (r *Rows) GetFloatSlice(row, column int) ([]float64, error) {
	value, err := r.GetValue(row, column)
	if err != nil {
		return nil, err
	}
	res, err := common.ConvertToSlice(value, reflect.Float64)
	if err != nil {
		return nil, err
	}
	return res.([]float64), nil
}
func (r *Rows) GetFloatSliceByName(row int, name string) ([]float64, error) {
	column, err := r.NameIndex(name)
	if err != nil {
		return nil, err
	}
	return r.GetFloatSlice(row, column)
}