|
|
|
package domainService
|
|
|
|
|
|
|
|
import (
|
|
|
|
"fmt"
|
|
|
|
"github.com/zeromicro/go-zero/core/collection"
|
|
|
|
"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/domain"
|
|
|
|
"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/repository"
|
|
|
|
"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/infrastructure/starrocks"
|
|
|
|
"gitlab.fjmaimaimai.com/allied-creation/character-library-metadata-bastion/pkg/log"
|
|
|
|
"strings"
|
|
|
|
)
|
|
|
|
|
|
|
|
const DefaultExpandNum = 10000
|
|
|
|
const MaxExpandNum = 50000
|
|
|
|
|
|
|
|
func (ptr *QuerySetService) LoadCalculateSetData(ctx *domain.Context, qs *domain.QuerySet, queryComponents []*domain.QueryComponent) (*domain.DataTable, error) {
|
|
|
|
var (
|
|
|
|
res = &domain.DataTable{}
|
|
|
|
dataTables = make(map[int]*domain.DataTable)
|
|
|
|
err error
|
|
|
|
)
|
|
|
|
|
|
|
|
if len(queryComponents) == 0 {
|
|
|
|
return res, nil
|
|
|
|
}
|
|
|
|
// 加载Tables数据
|
|
|
|
q := queryComponents[0]
|
|
|
|
cells := q.Layout.LayoutCells()
|
|
|
|
dataTables = ptr.LoadDataTables(ctx, cells)
|
|
|
|
// 数据布局
|
|
|
|
res, err = DataLayout(res, dataTables, cells)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
// 数据持久化
|
|
|
|
return res, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func FastTable(table *domain.Table) (*domain.DataTable, error) {
|
|
|
|
var err error
|
|
|
|
var options = starrocks.QueryOptions{
|
|
|
|
Table: table,
|
|
|
|
TableName: table.SQLName,
|
|
|
|
Select: table.Fields(false),
|
|
|
|
}
|
|
|
|
var dataTable *domain.DataTable
|
|
|
|
dataTable, err = FastDataTable(options)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return dataTable, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func FastDataTable(options starrocks.QueryOptions) (*domain.DataTable, error) {
|
|
|
|
var err error
|
|
|
|
// 待优化分批下载，压缩
|
|
|
|
var dataTable *domain.DataTable
|
|
|
|
dataTable, err = starrocks.Query(options, starrocks.WrapQueryFuncWithDB(starrocks.DB))
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
dataTable.Total, err = starrocks.WrapQueryCountWithDB(options, starrocks.DB)()
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
return dataTable, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (ptr *QuerySetService) LoadDataTables(ctx *domain.Context, cells []*domain.LayoutCell) map[int]*domain.DataTable {
|
|
|
|
var (
|
|
|
|
dataTables = make(map[int]*domain.DataTable)
|
|
|
|
tableRepository, _ = repository.NewTableRepository(ptr.transactionContext)
|
|
|
|
)
|
|
|
|
tableIds := collection.NewSet()
|
|
|
|
for _, cell := range cells {
|
|
|
|
if cell.Data == nil || cell.Data.TableField == nil || cell.Data.TableField.TableId == 0 {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
tableIds.AddInt(cell.Data.TableField.TableId)
|
|
|
|
}
|
|
|
|
if len(tableIds.KeysInt()) > 0 {
|
|
|
|
_, tables, err := tableRepository.Find(map[string]interface{}{"context": ctx, "tableIds": tableIds.KeysInt()})
|
|
|
|
if err != nil {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
for _, t := range tables {
|
|
|
|
if _, ok := dataTables[t.TableId]; ok {
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
dataTable, e := FastTable(t)
|
|
|
|
if e != nil {
|
|
|
|
log.Logger.Error(e.Error())
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
dataTable.Fields = t.DataFields
|
|
|
|
dataTables[t.TableId] = dataTable
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return dataTables
|
|
|
|
}
|
|
|
|
|
|
|
|
func DataLayout(res *domain.DataTable, dataTables map[int]*domain.DataTable, cells []*domain.LayoutCell) (*domain.DataTable, error) {
|
|
|
|
dt := &DataLayoutDataTable{
|
|
|
|
DataTable: res,
|
|
|
|
MapDataTables: dataTables,
|
|
|
|
unprocessed: cells,
|
|
|
|
}
|
|
|
|
dt.Init(DefaultExpandNum)
|
|
|
|
for {
|
|
|
|
if len(dt.unprocessed) == 0 {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
cell := dt.unprocessed[0]
|
|
|
|
dt.unprocessed = dt.unprocessed[1:]
|
|
|
|
blockData, length := dt.BlockData(cell)
|
|
|
|
if err := dt.Expand(cell, length); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
dt.addByLocation(cell, blockData)
|
|
|
|
// 当前单元格子 影响其他格子坐标
|
|
|
|
dt.changeUnProcessedLocation(cell, length)
|
|
|
|
dt.processed = append(dt.processed, cell)
|
|
|
|
dt.LastCell = cell
|
|
|
|
}
|
|
|
|
dt.Shrink()
|
|
|
|
return dt.DataTable, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
type DataLayoutDataTable struct {
|
|
|
|
PointBegin *Location
|
|
|
|
PointEnd *Location
|
|
|
|
MaxX int
|
|
|
|
MaxY int
|
|
|
|
DataTable *domain.DataTable
|
|
|
|
MapDataTables map[int]*domain.DataTable
|
|
|
|
processed []*domain.LayoutCell
|
|
|
|
unprocessed []*domain.LayoutCell
|
|
|
|
LastCell *domain.LayoutCell
|
|
|
|
}
|
|
|
|
|
|
|
|
type Location struct {
|
|
|
|
X int
|
|
|
|
Y int
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewLocation(x, y int) *Location {
|
|
|
|
return &Location{
|
|
|
|
X: x,
|
|
|
|
Y: y,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (l *Location) UpdateX(x int) {
|
|
|
|
if l.X <= x {
|
|
|
|
l.X = x
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (l *Location) UpdateY(y int) {
|
|
|
|
if l.Y <= y {
|
|
|
|
l.Y = y
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *DataLayoutDataTable) StartCell() {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *DataLayoutDataTable) addByLocation(cell *domain.LayoutCell, blockData []string) {
|
|
|
|
if d.PointBegin == nil {
|
|
|
|
d.PointBegin = NewLocation(cell.X, cell.Y)
|
|
|
|
d.PointEnd = NewLocation(cell.X, cell.Y)
|
|
|
|
}
|
|
|
|
switch cell.Direction {
|
|
|
|
case domain.DirectionRight:
|
|
|
|
for i := range blockData {
|
|
|
|
d.DataTable.Data[cell.X][cell.Y+i] = blockData[i]
|
|
|
|
}
|
|
|
|
d.PointEnd.UpdateX(cell.X)
|
|
|
|
d.PointEnd.UpdateY(cell.Y + len(blockData) - 1)
|
|
|
|
case domain.DirectionDown:
|
|
|
|
for i := range blockData {
|
|
|
|
d.DataTable.Data[cell.X+i][cell.Y] = blockData[i]
|
|
|
|
}
|
|
|
|
d.PointEnd.UpdateX(cell.X + len(blockData) - 1)
|
|
|
|
d.PointEnd.UpdateY(cell.Y)
|
|
|
|
case domain.DirectionNone:
|
|
|
|
d.DataTable.Data[cell.X][cell.Y] = blockData[0]
|
|
|
|
d.PointEnd.UpdateX(cell.X)
|
|
|
|
d.PointEnd.UpdateY(cell.Y)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *DataLayoutDataTable) changeUnProcessedLocation(lastCell *domain.LayoutCell, length int) {
|
|
|
|
// log.Logger.Info("修改定位点")
|
|
|
|
for _, cell := range d.unprocessed {
|
|
|
|
switch lastCell.Direction {
|
|
|
|
case domain.DirectionRight:
|
|
|
|
if cell.X >= lastCell.X && cell.Y > lastCell.Y {
|
|
|
|
cell.Y += length - 1
|
|
|
|
}
|
|
|
|
case domain.DirectionDown:
|
|
|
|
if cell.X > lastCell.X && cell.Y >= lastCell.Y {
|
|
|
|
cell.X += length - 1
|
|
|
|
}
|
|
|
|
}
|
|
|
|
// log.Logger.Info(fmt.Sprintf("%s %s X:%d Y:%d", cell.Data.Field.SQLName, cell.Direction, cell.X, cell.Y))
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *DataLayoutDataTable) BlockData(cells *domain.LayoutCell) ([]string, int) {
|
|
|
|
var block []string
|
|
|
|
if cells.Type == domain.CellTypeText {
|
|
|
|
data := []string{cells.Data.Text}
|
|
|
|
return data, 1
|
|
|
|
}
|
|
|
|
table, ok := d.MapDataTables[cells.Data.TableField.TableId]
|
|
|
|
if !ok {
|
|
|
|
return block, 0
|
|
|
|
}
|
|
|
|
values := table.Values(&domain.Field{SQLName: cells.Data.TableField.FieldSqlName})
|
|
|
|
if len(values) == 0 {
|
|
|
|
return block, 0
|
|
|
|
}
|
|
|
|
if cells.Data.TableField != nil && strings.HasPrefix(cells.Data.TableField.TableSqlName, strings.ToLower(domain.CalculateItem.ToString())) {
|
|
|
|
return values[:1], 1
|
|
|
|
}
|
|
|
|
if cells.Direction == domain.DirectionNone {
|
|
|
|
return values[:1], 1
|
|
|
|
}
|
|
|
|
return values, len(values)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *DataLayoutDataTable) Shrink() {
|
|
|
|
x := d.PointEnd.X - d.PointBegin.X
|
|
|
|
y := d.PointEnd.Y - d.PointBegin.Y
|
|
|
|
data := make([][]string, x+1)
|
|
|
|
for i := range data {
|
|
|
|
data[i] = make([]string, y+1)
|
|
|
|
}
|
|
|
|
iData := 0
|
|
|
|
for i := d.PointBegin.X; i <= d.PointEnd.X; i++ {
|
|
|
|
jData := 0
|
|
|
|
for j := d.PointBegin.Y; j <= d.PointEnd.Y; j++ {
|
|
|
|
data[iData][jData] = d.DataTable.Data[i][j]
|
|
|
|
jData++
|
|
|
|
}
|
|
|
|
iData++
|
|
|
|
}
|
|
|
|
d.DataTable.Data = data
|
|
|
|
for i := 0; i <= y; i++ {
|
|
|
|
d.DataTable.Fields = append(d.DataTable.Fields, &domain.Field{
|
|
|
|
Name: fmt.Sprintf("列%d", i),
|
|
|
|
SQLName: fmt.Sprintf("col%d", i),
|
|
|
|
SQLType: domain.String.ToString(),
|
|
|
|
})
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *DataLayoutDataTable) Expand(cell *domain.LayoutCell, length int) error {
|
|
|
|
if !d.CellOutRange(cell, length) {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
expandLength := DefaultExpandNum
|
|
|
|
if expandLength < length {
|
|
|
|
expandLength = length
|
|
|
|
}
|
|
|
|
if d.MaxX+expandLength > MaxExpandNum {
|
|
|
|
return fmt.Errorf("布局元素超过限制 %d", MaxExpandNum)
|
|
|
|
}
|
|
|
|
copyData := make([][]string, d.MaxX+length)
|
|
|
|
for i := range copyData {
|
|
|
|
copyData[i] = make([]string, d.MaxY+length)
|
|
|
|
}
|
|
|
|
copy(copyData, d.DataTable.Data)
|
|
|
|
d.DataTable.Data = copyData
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *DataLayoutDataTable) Init(length int) {
|
|
|
|
initData := make([][]string, length)
|
|
|
|
for i := range initData {
|
|
|
|
initData[i] = make([]string, length)
|
|
|
|
}
|
|
|
|
d.DataTable.Data = initData
|
|
|
|
d.AddRange(length)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *DataLayoutDataTable) AddRange(length int) {
|
|
|
|
d.MaxY += length
|
|
|
|
d.MaxX += length
|
|
|
|
}
|
|
|
|
|
|
|
|
func (d *DataLayoutDataTable) CellOutRange(cell *domain.LayoutCell, length int) bool {
|
|
|
|
if cell.X+length > d.MaxX {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
if cell.Y+length > d.MaxY {
|
|
|
|
return true
|
|
|
|
}
|
|
|
|
return false
|
|
|
|
} |
...
|
...
|
|
