gtsocial-umbx

model_map.go (3119B)

---

 package bun
 
 import (
 	"context"
 	"database/sql"
 	"reflect"
 	"sort"
 
 	"github.com/uptrace/bun/schema"
 )
 
 type mapModel struct {
 	db *DB
 
 	dest *map[string]interface{}
 	m    map[string]interface{}
 
 	rows         *sql.Rows
 	columns      []string
 	_columnTypes []*sql.ColumnType
 	scanIndex    int
 }
 
 var _ Model = (*mapModel)(nil)
 
 func newMapModel(db *DB, dest *map[string]interface{}) *mapModel {
 	m := &mapModel{
 		db:   db,
 		dest: dest,
 	}
 	if dest != nil {
 		m.m = *dest
 	}
 	return m
 }
 
 func (m *mapModel) Value() interface{} {
 	return m.dest
 }
 
 func (m *mapModel) ScanRows(ctx context.Context, rows *sql.Rows) (int, error) {
 	if !rows.Next() {
 		return 0, rows.Err()
 	}
 
 	columns, err := rows.Columns()
 	if err != nil {
 		return 0, err
 	}
 
 	m.rows = rows
 	m.columns = columns
 	dest := makeDest(m, len(columns))
 
 	if m.m == nil {
 		m.m = make(map[string]interface{}, len(m.columns))
 	}
 
 	m.scanIndex = 0
 	if err := rows.Scan(dest...); err != nil {
 		return 0, err
 	}
 
 	*m.dest = m.m
 
 	return 1, nil
 }
 
 func (m *mapModel) Scan(src interface{}) error {
 	if _, ok := src.([]byte); !ok {
 		return m.scanRaw(src)
 	}
 
 	columnTypes, err := m.columnTypes()
 	if err != nil {
 		return err
 	}
 
 	scanType := columnTypes[m.scanIndex].ScanType()
 	switch scanType.Kind() {
 	case reflect.Interface:
 		return m.scanRaw(src)
 	case reflect.Slice:
 		if scanType.Elem().Kind() == reflect.Uint8 {
 			return m.scanRaw(src)
 		}
 	}
 
 	dest := reflect.New(scanType).Elem()
 	if err := schema.Scanner(scanType)(dest, src); err != nil {
 		return err
 	}
 
 	return m.scanRaw(dest.Interface())
 }
 
 func (m *mapModel) columnTypes() ([]*sql.ColumnType, error) {
 	if m._columnTypes == nil {
 		columnTypes, err := m.rows.ColumnTypes()
 		if err != nil {
 			return nil, err
 		}
 		m._columnTypes = columnTypes
 	}
 	return m._columnTypes, nil
 }
 
 func (m *mapModel) scanRaw(src interface{}) error {
 	columnName := m.columns[m.scanIndex]
 	m.scanIndex++
 	m.m[columnName] = src
 	return nil
 }
 
 func (m *mapModel) appendColumnsValues(fmter schema.Formatter, b []byte) []byte {
 	keys := make([]string, 0, len(m.m))
 
 	for k := range m.m {
 		keys = append(keys, k)
 	}
 	sort.Strings(keys)
 
 	b = append(b, " ("...)
 
 	for i, k := range keys {
 		if i > 0 {
 			b = append(b, ", "...)
 		}
 		b = fmter.AppendIdent(b, k)
 	}
 
 	b = append(b, ") VALUES ("...)
 
 	isTemplate := fmter.IsNop()
 	for i, k := range keys {
 		if i > 0 {
 			b = append(b, ", "...)
 		}
 		if isTemplate {
 			b = append(b, '?')
 		} else {
 			b = schema.Append(fmter, b, m.m[k])
 		}
 	}
 
 	b = append(b, ")"...)
 
 	return b
 }
 
 func (m *mapModel) appendSet(fmter schema.Formatter, b []byte) []byte {
 	keys := make([]string, 0, len(m.m))
 
 	for k := range m.m {
 		keys = append(keys, k)
 	}
 	sort.Strings(keys)
 
 	isTemplate := fmter.IsNop()
 	for i, k := range keys {
 		if i > 0 {
 			b = append(b, ", "...)
 		}
 
 		b = fmter.AppendIdent(b, k)
 		b = append(b, " = "...)
 		if isTemplate {
 			b = append(b, '?')
 		} else {
 			b = schema.Append(fmter, b, m.m[k])
 		}
 	}
 
 	return b
 }
 
 func makeDest(v interface{}, n int) []interface{} {
 	dest := make([]interface{}, n)
 	for i := range dest {
 		dest[i] = v
 	}
 	return dest
 }