github.com/aacfactory/fns-contrib/databases/sql@v1.2.84/dac/specifications/table.go (about)

     1  package specifications
     2  
     3  import (
     4  	"fmt"
     5  	"github.com/aacfactory/errors"
     6  	"reflect"
     7  	"strings"
     8  )
     9  
    10  type TableInfo struct {
    11  	schema    string
    12  	name      string
    13  	conflicts []string
    14  }
    15  
    16  func MaybeTable(e any) (ok bool) {
    17  	rv := reflect.Indirect(reflect.ValueOf(e))
    18  	rt := rv.Type()
    19  	_, ok = rt.MethodByName("TableInfo")
    20  	return
    21  }
    22  
    23  func GetTableInfo(e any) (info TableInfo, err error) {
    24  	rv := reflect.Indirect(reflect.ValueOf(e))
    25  	rt := rv.Type()
    26  	// info
    27  	_, hasInfoFunc := rt.MethodByName("TableInfo")
    28  	if !hasInfoFunc {
    29  		err = errors.Warning(fmt.Sprintf("sql: %s.%s has not TableInfo func", rt.PkgPath(), rt.Name()))
    30  		return
    31  	}
    32  	infoFunc := rv.MethodByName("TableInfo")
    33  	results := infoFunc.Call(nil)
    34  	if len(results) != 1 {
    35  		err = errors.Warning(fmt.Sprintf("sql: %s.%s has invalid TableInfo func", rt.PkgPath(), rt.Name()))
    36  		return
    37  	}
    38  	result := results[0]
    39  	// name
    40  	_, hasNameFunc := result.Type().MethodByName("Name")
    41  	if !hasNameFunc {
    42  		err = errors.Warning(fmt.Sprintf("sql: %s.%s has not TableInfo func", rt.PkgPath(), rt.Name()))
    43  		return
    44  	}
    45  	nameResults := result.MethodByName("Name").Call(nil)
    46  	if len(nameResults) != 1 && nameResults[0].Type().Kind() != reflect.String {
    47  		err = errors.Warning(fmt.Sprintf("sql: %s.%s has invalid TableInfo func", rt.PkgPath(), rt.Name()))
    48  		return
    49  	}
    50  	name := nameResults[0].String()
    51  	// schema
    52  	_, hasSchemaFunc := result.Type().MethodByName("Schema")
    53  	if !hasSchemaFunc {
    54  		err = errors.Warning(fmt.Sprintf("sql: %s.%s has not TableInfo func", rt.PkgPath(), rt.Name()))
    55  		return
    56  	}
    57  	schemaResults := result.MethodByName("Schema").Call(nil)
    58  	if len(schemaResults) != 1 && schemaResults[0].Type().Kind() != reflect.String {
    59  		err = errors.Warning(fmt.Sprintf("sql: %s.%s has invalid TableInfo func", rt.PkgPath(), rt.Name()))
    60  		return
    61  	}
    62  	schema := schemaResults[0].String()
    63  	// conflicts
    64  	_, hasConflictsFunc := result.Type().MethodByName("Conflicts")
    65  	if !hasConflictsFunc {
    66  		err = errors.Warning(fmt.Sprintf("sql: %s.%s has not TableInfo func", rt.PkgPath(), rt.Name()))
    67  		return
    68  	}
    69  	conflictsResults := result.MethodByName("Conflicts").Call(nil)
    70  	if len(conflictsResults) != 1 && conflictsResults[0].Type().Kind() != reflect.Slice && conflictsResults[0].Type().Elem().Kind() != reflect.String {
    71  		err = errors.Warning(fmt.Sprintf("sql: %s.%s has invalid TableInfo func", rt.PkgPath(), rt.Name()))
    72  		return
    73  	}
    74  	conflicts := conflictsResults[0].Interface().([]string)
    75  	for i, conflict := range conflicts {
    76  		conflicts[i] = strings.TrimSpace(conflict)
    77  	}
    78  	// view
    79  	info = TableInfo{
    80  		schema:    strings.TrimSpace(schema),
    81  		name:      strings.TrimSpace(name),
    82  		conflicts: conflicts,
    83  	}
    84  	return
    85  }