fix: mata table query

@@ -19,7 +19,10 @@ type FieldOptionalValuesCommand struct {
 }
 }
 
 
 func (cmd *FieldOptionalValuesCommand) Valid(validation *validation.Validation) {
 func (cmd *FieldOptionalValuesCommand) Valid(validation *validation.Validation) {
-
+	if cmd.PageSize == 0 {
+		cmd.PageNumber = 1
+		cmd.PageSize = 2000
+	}
 }
 }
 
 
 func (cmd *FieldOptionalValuesCommand) ValidateCommand() error {
 func (cmd *FieldOptionalValuesCommand) ValidateCommand() error {

@@ -26,6 +26,10 @@ func (tableService *TableService) FieldOptionalValues(ctx *domain.Context, cmd *
 		transactionContext.RollbackTransaction()
 		transactionContext.RollbackTransaction()
 	}()
 	}()
 	var dataTable *domain.DataTable
 	var dataTable *domain.DataTable
+	var empty = map[string]interface{}{
+		"values": []string{},
+		"total":  0,
+	}
 	tableRepository, _, _ := factory.FastPgTable(transactionContext, 0)
 	tableRepository, _, _ := factory.FastPgTable(transactionContext, 0)
 	var table *domain.Table
 	var table *domain.Table
 	var db *gorm.DB
 	var db *gorm.DB
@@ -63,6 +67,9 @@ func (tableService *TableService) FieldOptionalValues(ctx *domain.Context, cmd *
 	if !ok {
 	if !ok {
 		return nil, factory.FastError(fmt.Errorf("列:%v 不存在", cmd.Field.Name))
 		return nil, factory.FastError(fmt.Errorf("列:%v 不存在", cmd.Field.Name))
 	}
 	}
+	if table.TableType == domain.SubTable.ToString() && field.Flag == domain.ManualField {
+		return empty, nil
+	}
 
 
 	options := &starrocks.QueryOptions{
 	options := &starrocks.QueryOptions{
 		TableName: table.SQLName,
 		TableName: table.SQLName,

@@ -24,7 +24,7 @@ type Condition struct {
 	Like  string        `json:"like"`
 	Like  string        `json:"like"`
 	In    []interface{} `json:"in"`
 	In    []interface{} `json:"in"`
 	Ex    []interface{} `json:"ex"`
 	Ex    []interface{} `json:"ex"`
-	Range []interface{} `json:"range"`
+	Range []RangStruct  `json:"range"`
 	Order string        `json:"order"`
 	Order string        `json:"order"`
 }
 }
 
 
@@ -44,3 +44,8 @@ func (t *DataTable) OptionalValue() []string {
 func (t *DataTable) MatchFields(from []*Field) []*Field {
 func (t *DataTable) MatchFields(from []*Field) []*Field {
 	return from
 	return from
 }
 }
+
+type RangStruct struct {
+	Op  string      `json:"op"`
+	Val interface{} `json:"val"`
+}

@@ -5,11 +5,14 @@ import (
 	"fmt"
 	"fmt"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/utils"
 	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/utils"
+	"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/log"
 	"gorm.io/gorm"
 	"gorm.io/gorm"
 	"reflect"
 	"reflect"
 	"strings"
 	"strings"
 )
 )
 
 
+var AssertString = utils.AssertString
+
 func Query(params QueryOptions, queryFunc func(params QueryOptions) (*sql.Rows, error)) (*domain.DataTable, error) {
 func Query(params QueryOptions, queryFunc func(params QueryOptions) (*sql.Rows, error)) (*domain.DataTable, error) {
 	rows, err := queryFunc(params)
 	rows, err := queryFunc(params)
 	if err != nil {
 	if err != nil {
@@ -97,6 +100,27 @@ func (c Condition) SetWhere(q *gorm.DB) {
 		in := c.InArgs(c.Ex)
 		in := c.InArgs(c.Ex)
 		q.Where(fmt.Sprintf("%v not in %v", c.Field.SQLName, in))
 		q.Where(fmt.Sprintf("%v not in %v", c.Field.SQLName, in))
 	}
 	}
+	if len(c.Range) > 0 {
+		for _, item := range c.Range {
+			if item.Op == "" {
+				continue
+			}
+			opVal, ok := opMap[item.Op]
+			if !ok {
+				continue
+			}
+			val, err := domain.ValueToType(AssertString(item.Val), c.Field.SQLType)
+			if err != nil {
+				log.Logger.Error(err.Error())
+				continue
+			}
+			q.Where(fmt.Sprintf("%s %s %s",
+				c.Field.SQLName,
+				opVal,
+				c.formatByOp(item.Op, val),
+			))
+		}
+	}
 	if c.Distinct {
 	if c.Distinct {
 		q.Distinct(c.Field.SQLName)
 		q.Distinct(c.Field.SQLName)
 	}
 	}
@@ -104,12 +128,37 @@ func (c Condition) SetWhere(q *gorm.DB) {
 		q.Order(fmt.Sprintf("%v %v", c.Field.SQLName, c.Order))
 		q.Order(fmt.Sprintf("%v %v", c.Field.SQLName, c.Order))
 	}
 	}
 }
 }
+
+var opMap = map[string]string{
+	"=":        "=",
+	">":        ">",
+	"<":        "<",
+	">=":       ">=",
+	"<=":       "<=",
+	"<>":       "<>",
+	"like":     "like",
+	"not like": "not like",
+}
+
+func (c Condition) formatByOp(op string, val interface{}) string {
+	if op == "like" || op == "not like" {
+		return fmt.Sprintf("'%%%v%%'", AssertString(val))
+	}
+	return c.Arg(val)
+}
+
 func (c Condition) InArgs(args interface{}) string {
 func (c Condition) InArgs(args interface{}) string {
 	bytes := make([]byte, 0)
 	bytes := make([]byte, 0)
 	bytes = appendIn(bytes, reflect.ValueOf(args))
 	bytes = appendIn(bytes, reflect.ValueOf(args))
 	return string(bytes)
 	return string(bytes)
 }
 }
 
 
+func (c Condition) Arg(args interface{}) string {
+	bytes := make([]byte, 0)
+	bytes = appendValue(bytes, reflect.ValueOf(args))
+	return string(bytes)
+}
+
 func appendIn(b []byte, slice reflect.Value) []byte {
 func appendIn(b []byte, slice reflect.Value) []byte {
 	sliceLen := slice.Len()
 	sliceLen := slice.Len()
 	b = append(b, '(')
 	b = append(b, '(')
@@ -186,7 +235,7 @@ func queryWithoutLimitOffset(query *gorm.DB, params QueryOptions) {
 	if len(params.Select) > 0 {
 	if len(params.Select) > 0 {
 		fields := make([]string, 0)
 		fields := make([]string, 0)
 		for _, f := range params.Select {
 		for _, f := range params.Select {
-			if f.Flag==domain.ManualField{
+			if f.Flag == domain.ManualField {
 				fields = append(fields, "'' "+f.SQLName)
 				fields = append(fields, "'' "+f.SQLName)
 				continue
 				continue
 			}
 			}
@@ -226,7 +275,7 @@ func WrapQueryCountWithDB(params QueryOptions, db *gorm.DB) func() (int64, error
 func ArrayInterfaceToString(args []interface{}) []string {
 func ArrayInterfaceToString(args []interface{}) []string {
 	result := make([]string, 0)
 	result := make([]string, 0)
 	for _, arg := range args {
 	for _, arg := range args {
-		result = append(result, utils.AssertString(arg))
+		result = append(result, AssertString(arg))
 	}
 	}
 	return result
 	return result
 }
 }

@@ -27,7 +27,7 @@ func Init() error {
 			Colorful:                  false,       // Disable color
 			Colorful:                  false,       // Disable color
 		},
 		},
 	)
 	)
-	DB, err = gorm.Open(mysql.Open(constant.STARROCKS_MYSQL_DATA_SOURCE), &gorm.Config{Logger: newLogger})
+	DB, err = gorm.Open(mysql.Open(constant.STARROCKS_MYSQL_DATA_SOURCE), &gorm.Config{Logger: newLogger, PrepareStmt: false})
 
 
 	//Test1()
 	//Test1()
 	return err
 	return err