Skip to content

Commit b57f07a

Browse files
dk-lockdowndk-lockdown
committed
feat: support show stmt
1 parent b318070 commit b57f07a

4 files changed

Lines changed: 284 additions & 11 deletions

File tree

‎pkg/dt/schema/table_records.go‎

Lines changed: 40 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -88,7 +88,47 @@ func BuildTableRecords(meta TableMeta, result *mysql.Result) *TableRecords {
8888
rs := make([]*Row, 0)
8989

9090
for _, row := range result.Rows {
91+
<<<<<<< HEAD
9192
values, err := row.Decode()
93+
=======
94+
binaryRow := mysql.BinaryRow{Row: row.(*mysql.Row)}
95+
values, err := binaryRow.Decode()
96+
if err != nil {
97+
break
98+
}
99+
fields := make([]*Field, 0, len(result.Fields))
100+
for i, col := range result.Fields {
101+
field := &Field{
102+
Name: col.FiledName(),
103+
Type: meta.AllColumns[col.FiledName()].DataType,
104+
}
105+
if values[i] != nil {
106+
field.Value = values[i].Val
107+
}
108+
if strings.EqualFold(col.FiledName(), meta.GetPKName()) {
109+
field.KeyType = PrimaryKey
110+
}
111+
fields = append(fields, field)
112+
}
113+
r := &Row{Fields: fields}
114+
rs = append(rs, r)
115+
}
116+
117+
if len(rs) == 0 {
118+
return nil
119+
}
120+
records.Rows = rs
121+
return records
122+
}
123+
124+
func BuildTextRecords(meta TableMeta, result *mysql.Result) *TableRecords {
125+
records := NewTableRecords(meta)
126+
rs := make([]*Row, 0)
127+
128+
for _, row := range result.Rows {
129+
textRow := mysql.TextRow{Row: row.(*mysql.Row)}
130+
values, err := textRow.Decode()
131+
>>>>>>> 08c063b (bugfix)
92132
if err != nil {
93133
break
94134
}

‎pkg/executor/sharding.go‎

Lines changed: 21 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -211,7 +211,9 @@ func (executor *ShardingExecutor) ExecutorComQuery(ctx context.Context, sql stri
211211
if queryStmt == nil {
212212
return nil, 0, errors.New("query stmt should not be nil")
213213
}
214-
if _, ok := queryStmt.(*ast.SetStmt); ok {
214+
215+
switch stmt := queryStmt.(type) {
216+
case *ast.SetStmt:
215217
for _, db := range executor.all {
216218
go func(db *DataSourceBrief) {
217219
if _, _, err := db.DB.Query(spanCtx, sql); err != nil {
@@ -224,20 +226,28 @@ func (executor *ShardingExecutor) ExecutorComQuery(ctx context.Context, sql stri
224226
AffectedRows: 0,
225227
InsertId: 0,
226228
}, 0, nil
227-
}
228-
if selectStmt, ok := queryStmt.(*ast.SelectStmt); ok {
229-
if selectStmt.Fields != nil && len(selectStmt.Fields.Fields) > 0 {
230-
if _, ok := selectStmt.Fields.Fields[0].Expr.(*ast.VariableExpr); ok {
229+
case *ast.ShowStmt:
230+
return executor.all[0].DB.Query(spanCtx, sql)
231+
case *ast.SelectStmt:
232+
if stmt.Fields != nil && len(stmt.Fields.Fields) > 0 {
233+
if _, ok := stmt.Fields.Fields[0].Expr.(*ast.VariableExpr); ok {
231234
return executor.all[0].DB.Query(spanCtx, sql)
232235
}
233236
}
237+
plan, err = executor.optimizer.Optimize(spanCtx, queryStmt)
238+
if err != nil {
239+
return nil, 0, err
240+
}
241+
proto.WithVariable(spanCtx, constant.TransactionTimeout, executor.config.TransactionTimeout)
242+
return plan.Execute(spanCtx)
243+
default:
244+
plan, err = executor.optimizer.Optimize(spanCtx, queryStmt)
245+
if err != nil {
246+
return nil, 0, err
247+
}
248+
proto.WithVariable(spanCtx, constant.TransactionTimeout, executor.config.TransactionTimeout)
249+
return plan.Execute(spanCtx)
234250
}
235-
plan, err = executor.optimizer.Optimize(spanCtx, queryStmt)
236-
if err != nil {
237-
return nil, 0, err
238-
}
239-
proto.WithVariable(spanCtx, constant.TransactionTimeout, executor.config.TransactionTimeout)
240-
return plan.Execute(spanCtx)
241251
}
242252

243253
func (executor *ShardingExecutor) ExecutorComStmtExecute(

‎pkg/plan/result.go‎

Lines changed: 169 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -193,11 +193,22 @@ func mergeResultWithoutOrderByAndLimit(ctx context.Context,
193193
var (
194194
fields []*mysql.Field
195195
warning uint16 = 0
196+
<<<<<<< HEAD
196197
rows = make([]proto.Row, 0)
197198
// Record whether mysql.Result has been traversed
198199
endResult = make([]bool, len(results))
199200
rowIndexes = make([]int, len(results))
200201
endCount = 0
202+
=======
203+
204+
commandType = proto.CommandType(ctx)
205+
rows = make([]proto.Row, 0)
206+
// Record whether mysql.Result has been traversed
207+
endResult = make([]bool, len(results))
208+
endCount = 0
209+
210+
rowIndexs = make([]int, len(results))
211+
>>>>>>> 08c063b (bugfix)
201212
)
202213
for _, rlt := range results {
203214
warning += rlt.Warning
@@ -208,16 +219,37 @@ func mergeResultWithoutOrderByAndLimit(ctx context.Context,
208219
continue
209220
}
210221
result := rlt.Result.(*mysql.Result)
222+
<<<<<<< HEAD
211223
row := result.Rows[rowIndexes[i]]
212224
rowIndexes[i]++
213225
if rowIndexes[i] == len(result.Rows) {
226+
=======
227+
row := result.Rows[rowIndexs[i]]
228+
rowIndexs[i]++
229+
if rowIndexs[i] == len(result.Rows) {
230+
>>>>>>> 08c063b (bugfix)
214231
endResult[i] = true
215232
endCount += 1
216233
continue
217234
}
218235

236+
<<<<<<< HEAD
219237
if _, err := row.Decode(); err != nil {
220238
log.Panic(err)
239+
=======
240+
if commandType == constant.ComQuery {
241+
textRow := &mysql.TextRow{Row: row.(*mysql.Row)}
242+
if _, err := textRow.Decode(); err != nil {
243+
log.Panic(err)
244+
}
245+
rows = append(rows, textRow)
246+
} else {
247+
binaryRow := &mysql.BinaryRow{Row: row.(*mysql.Row)}
248+
if _, err := binaryRow.Decode(); err != nil {
249+
log.Panic(err)
250+
}
251+
rows = append(rows, binaryRow)
252+
>>>>>>> 08c063b (bugfix)
221253
}
222254
rows = append(rows, row)
223255
}
@@ -240,6 +272,7 @@ func mergeResultWithLimit(ctx context.Context,
240272
results []*ResultWithErr,
241273
limit *Limit) (*mysql.Result, uint16) {
242274
var (
275+
<<<<<<< HEAD
243276
fields []*mysql.Field
244277
warning uint16 = 0
245278
offset int64
@@ -250,6 +283,21 @@ func mergeResultWithLimit(ctx context.Context,
250283
endResult = make([]bool, len(results))
251284
rowIndexes = make([]int, len(results))
252285
endCount = 0
286+
=======
287+
fields []*mysql.Field
288+
warning uint16 = 0
289+
offset int64
290+
count int64
291+
rowCount int64
292+
commandType = proto.CommandType(ctx)
293+
294+
rows = make([]proto.Row, 0)
295+
// Record whether mysql.Result has been traversed
296+
endResult = make([]bool, len(results))
297+
endCount = 0
298+
299+
rowIndexs = make([]int, len(results))
300+
>>>>>>> 08c063b (bugfix)
253301
)
254302
for _, rlt := range results {
255303
warning += rlt.Warning
@@ -263,9 +311,15 @@ func mergeResultWithLimit(ctx context.Context,
263311
continue
264312
}
265313
result := rlt.Result.(*mysql.Result)
314+
<<<<<<< HEAD
266315
row := result.Rows[rowIndexes[i]]
267316
rowIndexes[i]++
268317
if rowIndexes[i] == len(result.Rows) {
318+
=======
319+
row := result.Rows[rowIndexs[i]]
320+
rowIndexs[i]++
321+
if rowIndexs[i] == len(result.Rows) {
322+
>>>>>>> 08c063b (bugfix)
269323
endResult[i] = true
270324
endCount += 1
271325
continue
@@ -275,8 +329,23 @@ func mergeResultWithLimit(ctx context.Context,
275329
if int64(len(rows)) == count {
276330
break
277331
}
332+
<<<<<<< HEAD
278333
if _, err := row.Decode(); err != nil {
279334
log.Panic(err)
335+
=======
336+
if commandType == constant.ComQuery {
337+
textRow := &mysql.TextRow{Row: row.(*mysql.Row)}
338+
if _, err := textRow.Decode(); err != nil {
339+
log.Panic(err)
340+
}
341+
rows = append(rows, textRow)
342+
} else {
343+
binaryRow := &mysql.BinaryRow{Row: row.(*mysql.Row)}
344+
if _, err := binaryRow.Decode(); err != nil {
345+
log.Panic(err)
346+
}
347+
rows = append(rows, binaryRow)
348+
>>>>>>> 08c063b (bugfix)
280349
}
281350
rows = append(rows, row)
282351
}
@@ -303,6 +372,7 @@ func mergeResultWithOrderByAndLimit(ctx context.Context,
303372
var (
304373
fields []*mysql.Field
305374
orderByFields []*OrderField
375+
<<<<<<< HEAD
306376
warning uint16 = 0
307377
offset int64
308378
count int64
@@ -312,6 +382,20 @@ func mergeResultWithOrderByAndLimit(ctx context.Context,
312382
endResult = make([]bool, len(results))
313383
rowIndexes = make([]int, len(results))
314384
endCount = 0
385+
=======
386+
387+
commandType = proto.CommandType(ctx)
388+
warning uint16 = 0
389+
offset int64
390+
count int64
391+
rowCount int64
392+
rows = make([]proto.Row, 0)
393+
cells = make([]*OrderByCell, len(results))
394+
endResult = make([]bool, len(results))
395+
endCount = 0
396+
397+
rowIndexs = make([]int, len(results))
398+
>>>>>>> 08c063b (bugfix)
315399
)
316400
fields = results[0].Result.(*mysql.Result).Fields
317401
orderByFields = castOrderByItemsToOrderField(orderBy, fields)
@@ -322,15 +406,22 @@ func mergeResultWithOrderByAndLimit(ctx context.Context,
322406
for i, rlt := range results {
323407
if (cells[i] == nil || cells[i].next) && !endResult[i] {
324408
result := rlt.Result.(*mysql.Result)
409+
<<<<<<< HEAD
325410
row := result.Rows[rowIndexes[i]]
326411
rowIndexes[i]++
327412
if rowIndexes[i] == len(result.Rows) {
413+
=======
414+
row := result.Rows[rowIndexs[i]]
415+
rowIndexs[i]++
416+
if rowIndexs[i] == len(result.Rows) {
417+
>>>>>>> 08c063b (bugfix)
328418
endResult[i] = true
329419
endCount += 1
330420
continue
331421
}
332422

333423
orderFields := copyOrderFields(orderByFields)
424+
<<<<<<< HEAD
334425
values, err := row.Decode()
335426
if err != nil {
336427
log.Fatal(err)
@@ -343,6 +434,38 @@ func mergeResultWithOrderByAndLimit(ctx context.Context,
343434
orderField: orderFields,
344435
next: false,
345436
row: row,
437+
=======
438+
if commandType == constant.ComQuery {
439+
textRow := &mysql.TextRow{Row: row.(*mysql.Row)}
440+
values, err := textRow.Decode()
441+
if err != nil {
442+
log.Panic(err)
443+
}
444+
for _, of := range orderFields {
445+
of.value = values[of.fieldValueIndex].Val
446+
}
447+
448+
cells[i] = &OrderByCell{
449+
orderField: orderFields,
450+
next: false,
451+
row: textRow,
452+
}
453+
} else {
454+
binaryRow := &mysql.BinaryRow{Row: row.(*mysql.Row)}
455+
values, err := binaryRow.Decode()
456+
if err != nil {
457+
log.Fatal(err)
458+
}
459+
for _, of := range orderFields {
460+
of.value = values[of.fieldValueIndex].Val
461+
}
462+
463+
cells[i] = &OrderByCell{
464+
orderField: orderFields,
465+
next: false,
466+
row: binaryRow,
467+
}
468+
>>>>>>> 08c063b (bugfix)
346469
}
347470
}
348471
}
@@ -393,25 +516,39 @@ func mergeResultWithOrderBy(ctx context.Context,
393516
// OrderBy compare
394517
cells = make([]*OrderByCell, len(results))
395518
// Record whether mysql.Result has been traversed
519+
<<<<<<< HEAD
396520
endResult = make([]bool, len(results))
397521
rowIndexes = make([]int, len(results))
398522
endCount = 0
523+
=======
524+
endResult = make([]bool, len(results))
525+
endCount = 0
526+
527+
rowIndexs = make([]int, len(results))
528+
>>>>>>> 08c063b (bugfix)
399529
)
400530
fields = results[0].Result.(*mysql.Result).Fields
401531
orderByFields = castOrderByItemsToOrderField(orderBy, fields)
402532
for {
403533
for i, rlt := range results {
404534
if (cells[i] == nil || cells[i].next) && !endResult[i] {
405535
result := rlt.Result.(*mysql.Result)
536+
<<<<<<< HEAD
406537
row := result.Rows[rowIndexes[i]]
407538
rowIndexes[i]++
408539
if rowIndexes[i] == len(result.Rows) {
540+
=======
541+
row := result.Rows[rowIndexs[i]]
542+
rowIndexs[i]++
543+
if rowIndexs[i] == len(result.Rows) {
544+
>>>>>>> 08c063b (bugfix)
409545
endResult[i] = true
410546
endCount += 1
411547
continue
412548
}
413549

414550
orderFields := copyOrderFields(orderByFields)
551+
<<<<<<< HEAD
415552
values, err := row.Decode()
416553
if err != nil {
417554
log.Fatal(err)
@@ -424,6 +561,38 @@ func mergeResultWithOrderBy(ctx context.Context,
424561
orderField: orderFields,
425562
next: false,
426563
row: row,
564+
=======
565+
if commandType == constant.ComQuery {
566+
textRow := &mysql.TextRow{Row: row.(*mysql.Row)}
567+
values, err := textRow.Decode()
568+
if err != nil {
569+
log.Panic(err)
570+
}
571+
for _, of := range orderFields {
572+
of.value = values[of.fieldValueIndex].Val
573+
}
574+
575+
cells[i] = &OrderByCell{
576+
orderField: orderFields,
577+
next: false,
578+
row: textRow,
579+
}
580+
} else {
581+
binaryRow := &mysql.BinaryRow{Row: row.(*mysql.Row)}
582+
values, err := binaryRow.Decode()
583+
if err != nil {
584+
log.Fatal(err)
585+
}
586+
for _, of := range orderFields {
587+
of.value = values[of.fieldValueIndex].Val
588+
}
589+
590+
cells[i] = &OrderByCell{
591+
orderField: orderFields,
592+
next: false,
593+
row: binaryRow,
594+
}
595+
>>>>>>> 08c063b (bugfix)
427596
}
428597
}
429598
}

0 commit comments

Comments
 (0)