github.com/runner-mei/ql@v1.1.0/plan.go (about) 1 // Copyright 2015 The ql Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style 3 // license that can be found in the LICENSE file. 4 5 package ql 6 7 import ( 8 "bytes" 9 "fmt" 10 "strings" 11 12 "github.com/cznic/b" 13 "github.com/cznic/strutil" 14 ) 15 16 const ( 17 _ = iota 18 indexEq // [L] 19 indexFalse // [false] 20 indexGe // [L, ...) 21 indexGt // (L, ...) 22 indexIsNotNull // (NULL, ...) 23 indexIsNull // [NULL] 24 indexIntervalCC // [L, H] 25 indexIntervalCO // [L, H) 26 indexIntervalOC // (L, H] 27 indexIntervalOO // (L, H) 28 indexLe // (..., H] 29 indexLt // (..., H) 30 indexNe // (L) 31 indexTrue // [true] 32 ) 33 34 // Note: All plans must have a pointer receiver. Enables planA == planB operation. 35 var ( 36 _ plan = (*crossJoinDefaultPlan)(nil) 37 _ plan = (*distinctDefaultPlan)(nil) 38 _ plan = (*explainDefaultPlan)(nil) 39 _ plan = (*filterDefaultPlan)(nil) 40 _ plan = (*fullJoinDefaultPlan)(nil) 41 _ plan = (*groupByDefaultPlan)(nil) 42 _ plan = (*indexPlan)(nil) 43 _ plan = (*leftJoinDefaultPlan)(nil) 44 _ plan = (*limitDefaultPlan)(nil) 45 _ plan = (*nullPlan)(nil) 46 _ plan = (*offsetDefaultPlan)(nil) 47 _ plan = (*orderByDefaultPlan)(nil) 48 _ plan = (*rightJoinDefaultPlan)(nil) 49 _ plan = (*selectFieldsDefaultPlan)(nil) 50 _ plan = (*selectFieldsGroupPlan)(nil) 51 _ plan = (*selectIndexDefaultPlan)(nil) 52 _ plan = (*sysColumnDefaultPlan)(nil) 53 _ plan = (*sysIndexDefaultPlan)(nil) 54 _ plan = (*sysTableDefaultPlan)(nil) 55 _ plan = (*tableDefaultPlan)(nil) 56 _ plan = (*tableNilPlan)(nil) 57 ) 58 59 type plan interface { 60 do(ctx *execCtx, f func(id interface{}, data []interface{}) (more bool, err error)) error 61 explain(w strutil.Formatter) 62 fieldNames() []string 63 filter(expr expression) (p plan, indicesSought []string, err error) 64 hasID() bool 65 } 66 67 func isTableOrIndex(p plan) bool { 68 switch p.(type) { 69 case 70 *indexPlan, 71 *sysColumnDefaultPlan, 72 *sysIndexDefaultPlan, 73 *sysTableDefaultPlan, 74 *tableDefaultPlan: 75 return true 76 default: 77 return false 78 } 79 } 80 81 // Invariants 82 // - All interval plans produce rows in ascending index value collating order. 83 // - L <= H 84 type indexPlan struct { 85 src *table 86 cname string 87 xname string 88 x btreeIndex 89 kind int // See interval* consts. 90 lval interface{} // L, H: Ordered and comparable (lldb perspective). 91 hval interface{} 92 } 93 94 func (r *indexPlan) doGe(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 95 // nil, nil, ..., L-1, L-1, L, L, L+1, L+1, ... 96 // --- --- --- --- --- + + +++ +++ +++ 97 t := r.src 98 it, _, err := r.x.Seek([]interface{}{r.lval}) 99 if err != nil { 100 return noEOF(err) 101 } 102 103 for { 104 _, h, err := it.Next() 105 if err != nil { 106 return noEOF(err) 107 } 108 109 id, data, err := t.row(ctx, h) 110 if err != nil { 111 return err 112 } 113 114 if more, err := f(id, data); err != nil || !more { 115 return err 116 } 117 } 118 } 119 120 func (r *indexPlan) doGt(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 121 // nil, nil, ..., L-1, L-1, L, L, L+1, L+1, ... 122 // --- --- --- --- --- - - +++ +++ +++ 123 t := r.src 124 it, _, err := r.x.Seek([]interface{}{r.lval}) 125 if err != nil { 126 return noEOF(err) 127 } 128 129 var ok bool 130 for { 131 k, h, err := it.Next() 132 if err != nil { 133 return noEOF(err) 134 } 135 136 if !ok { 137 val, err := expand1(k[0], nil) 138 if err != nil { 139 return err 140 } 141 142 if collate1(val, r.lval) == 0 { 143 continue 144 } 145 146 ok = true 147 } 148 149 id, data, err := t.row(ctx, h) 150 if err != nil { 151 return err 152 } 153 154 if more, err := f(id, data); err != nil || !more { 155 return err 156 } 157 } 158 } 159 160 func (r *indexPlan) doInterval00(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 161 // nil, nil, ..., L-1, L-1, L, L, L+1, L+1, ..., H-1, H-1, H, H, H+1, H+1, ... 162 // --- --- --- --- --- - - +++ +++ +++ +++ +++ - - --- --- --- 163 t := r.src 164 it, _, err := r.x.Seek([]interface{}{r.lval}) 165 if err != nil { 166 return noEOF(err) 167 } 168 169 var ok bool 170 for { 171 k, h, err := it.Next() 172 if err != nil { 173 return noEOF(err) 174 } 175 176 if !ok { 177 val, err := expand1(k[0], nil) 178 if err != nil { 179 return err 180 } 181 182 if collate1(val, r.lval) == 0 { 183 continue 184 } 185 186 ok = true 187 } 188 189 val, err := expand1(k[0], nil) 190 if err != nil { 191 return err 192 } 193 194 if collate1(val, r.hval) == 0 { 195 return nil 196 } 197 198 id, data, err := t.row(ctx, h) 199 if err != nil { 200 return err 201 } 202 203 if more, err := f(id, data); err != nil || !more { 204 return err 205 } 206 } 207 } 208 209 func (r *indexPlan) doIntervalOC(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 210 // nil, nil, ..., L-1, L-1, L, L, L+1, L+1, ..., H-1, H-1, H, H, H+1, H+1, ... 211 // --- --- --- --- --- - - +++ +++ +++ +++ +++ + + --- --- --- 212 t := r.src 213 it, _, err := r.x.Seek([]interface{}{r.lval}) 214 if err != nil { 215 return noEOF(err) 216 } 217 218 var ok bool 219 for { 220 k, h, err := it.Next() 221 if err != nil { 222 return noEOF(err) 223 } 224 225 if !ok { 226 val, err := expand1(k[0], nil) 227 if err != nil { 228 return err 229 } 230 231 if collate1(val, r.lval) == 0 { 232 continue 233 } 234 235 ok = true 236 } 237 238 val, err := expand1(k[0], nil) 239 if err != nil { 240 return err 241 } 242 243 if collate1(val, r.hval) > 0 { 244 return nil 245 } 246 247 id, data, err := t.row(ctx, h) 248 if err != nil { 249 return err 250 } 251 252 if more, err := f(id, data); err != nil || !more { 253 return err 254 } 255 } 256 } 257 258 func (r *indexPlan) doIntervalCC(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 259 // nil, nil, ..., L-1, L-1, L, L, L+1, L+1, ..., H-1, H-1, H, H, H+1, H+1, ... 260 // --- --- --- --- --- + + +++ +++ +++ +++ +++ + + --- --- --- 261 t := r.src 262 it, _, err := r.x.Seek([]interface{}{r.lval}) 263 if err != nil { 264 return noEOF(err) 265 } 266 267 for { 268 k, h, err := it.Next() 269 if err != nil { 270 return noEOF(err) 271 } 272 273 val, err := expand1(k[0], nil) 274 if err != nil { 275 return err 276 } 277 278 if collate1(val, r.hval) > 0 { 279 return nil 280 } 281 282 id, data, err := t.row(ctx, h) 283 if err != nil { 284 return err 285 } 286 287 if more, err := f(id, data); err != nil || !more { 288 return err 289 } 290 } 291 } 292 293 func (r *indexPlan) doIntervalCO(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 294 // nil, nil, ..., L-1, L-1, L, L, L+1, L+1, ..., H-1, H-1, H, H, H+1, H+1, ... 295 // --- --- --- --- --- + + +++ +++ +++ +++ +++ - - --- --- --- 296 t := r.src 297 it, _, err := r.x.Seek([]interface{}{r.lval}) 298 if err != nil { 299 return noEOF(err) 300 } 301 302 for { 303 k, h, err := it.Next() 304 if err != nil { 305 return noEOF(err) 306 } 307 308 val, err := expand1(k[0], nil) 309 if err != nil { 310 return err 311 } 312 313 if collate1(val, r.hval) >= 0 { 314 return nil 315 } 316 317 id, data, err := t.row(ctx, h) 318 if err != nil { 319 return err 320 } 321 322 if more, err := f(id, data); err != nil || !more { 323 return err 324 } 325 } 326 } 327 328 func (r *indexPlan) doLe(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 329 // nil, nil, ..., H-1, H-1, H, H, H+1, H+1, ... 330 // --- --- +++ +++ +++ + + --- --- 331 t := r.src 332 it, err := r.x.SeekFirst() 333 if err != nil { 334 return noEOF(err) 335 } 336 337 for { 338 k, h, err := it.Next() 339 if err != nil { 340 return noEOF(err) 341 } 342 343 if k == nil || k[0] == nil { 344 continue 345 } 346 347 val, err := expand1(k[0], nil) 348 if err != nil { 349 return err 350 } 351 352 if collate1(val, r.hval) > 0 { 353 return nil 354 } 355 356 id, data, err := t.row(ctx, h) 357 if err != nil { 358 return err 359 } 360 361 if more, err := f(id, data); err != nil || !more { 362 return err 363 } 364 } 365 } 366 367 func (r *indexPlan) doLt(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 368 // nil, nil, ..., H-1, H-1, H, H, H+1, H+1, ... 369 // --- --- +++ +++ +++ - - --- --- 370 t := r.src 371 it, err := r.x.SeekFirst() 372 if err != nil { 373 return noEOF(err) 374 } 375 376 for { 377 k, h, err := it.Next() 378 if err != nil { 379 return noEOF(err) 380 } 381 382 if k == nil || k[0] == nil { 383 continue 384 } 385 386 val, err := expand1(k[0], nil) 387 if err != nil { 388 return err 389 } 390 391 if collate1(val, r.hval) >= 0 { 392 return nil 393 } 394 395 id, data, err := t.row(ctx, h) 396 if err != nil { 397 return err 398 } 399 400 if more, err := f(id, data); err != nil || !more { 401 return err 402 } 403 } 404 } 405 406 func (r *indexPlan) doEq(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 407 // nil, nil, ..., L-1, L-1, L, L, L+1, L+1, ... 408 // --- --- --- --- --- + + --- --- --- 409 t := r.src 410 it, _, err := r.x.Seek([]interface{}{r.lval}) 411 if err != nil { 412 return noEOF(err) 413 } 414 415 for { 416 k, h, err := it.Next() 417 if err != nil { 418 return noEOF(err) 419 } 420 421 val, err := expand1(k[0], nil) 422 if err != nil { 423 return err 424 } 425 426 if collate1(val, r.lval) != 0 { 427 return nil 428 } 429 430 id, data, err := t.row(ctx, h) 431 if err != nil { 432 return err 433 } 434 435 if more, err := f(id, data); err != nil || !more { 436 return err 437 } 438 } 439 } 440 441 func (r *indexPlan) doNe(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 442 // nil, nil, ..., L-1, L-1, L, L, L+1, L+1, ... 443 // --- --- +++ +++ +++ - - +++ +++ +++ 444 t := r.src 445 it, err := r.x.SeekFirst() 446 if err != nil { 447 return noEOF(err) 448 } 449 450 for { 451 k, h, err := it.Next() 452 if err != nil { 453 return noEOF(err) 454 } 455 456 if k == nil || k[0] == nil { 457 continue 458 } 459 460 val, err := expand1(k[0], nil) 461 if err != nil { 462 return err 463 } 464 465 if collate1(val, r.hval) == 0 { 466 continue 467 } 468 469 id, data, err := t.row(ctx, h) 470 if err != nil { 471 return err 472 } 473 474 if more, err := f(id, data); err != nil || !more { 475 return err 476 } 477 } 478 } 479 480 func (r *indexPlan) doIsNull(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 481 // nil, nil, ... 482 // +++ +++ --- 483 t := r.src 484 it, err := r.x.SeekFirst() 485 if err != nil { 486 return noEOF(err) 487 } 488 489 for { 490 k, h, err := it.Next() 491 if err != nil { 492 return noEOF(err) 493 } 494 495 if k != nil && k[0] != nil { 496 return nil 497 } 498 499 id, data, err := t.row(ctx, h) 500 if err != nil { 501 return err 502 } 503 504 if more, err := f(id, data); err != nil || !more { 505 return err 506 } 507 } 508 } 509 510 func (r *indexPlan) doIsNotNull(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 511 // nil, nil, ... 512 // --- --- +++ 513 t := r.src 514 it, _, err := r.x.Seek([]interface{}{false}) // lldb collates false right after NULL. 515 if err != nil { 516 return noEOF(err) 517 } 518 519 for { 520 _, h, err := it.Next() 521 if err != nil { 522 return noEOF(err) 523 } 524 525 id, data, err := t.row(ctx, h) 526 if err != nil { 527 return err 528 } 529 530 if more, err := f(id, data); err != nil || !more { 531 return err 532 } 533 } 534 } 535 536 func (r *indexPlan) doFalse(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 537 t := r.src 538 it, _, err := r.x.Seek([]interface{}{false}) 539 if err != nil { 540 return noEOF(err) 541 } 542 543 for { 544 k, h, err := it.Next() 545 if err != nil { 546 return noEOF(err) 547 } 548 549 b, ok := k[0].(bool) 550 if !ok || b { 551 return nil 552 } 553 554 id, data, err := t.row(ctx, h) 555 if err != nil { 556 return err 557 } 558 559 if more, err := f(id, data); err != nil || !more { 560 return err 561 } 562 } 563 } 564 565 func (r *indexPlan) doTrue(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 566 t := r.src 567 it, _, err := r.x.Seek([]interface{}{true}) 568 if err != nil { 569 return noEOF(err) 570 } 571 572 for { 573 k, h, err := it.Next() 574 if err != nil { 575 return noEOF(err) 576 } 577 578 if _, ok := k[0].(bool); !ok { 579 return nil 580 } 581 582 id, data, err := t.row(ctx, h) 583 if err != nil { 584 return err 585 } 586 587 if more, err := f(id, data); err != nil || !more { 588 return err 589 } 590 } 591 } 592 593 func (r *indexPlan) do(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) error { 594 switch r.kind { 595 case indexEq: 596 return r.doEq(ctx, f) 597 case indexGe: 598 return r.doGe(ctx, f) 599 case indexGt: 600 return r.doGt(ctx, f) 601 case indexLe: 602 return r.doLe(ctx, f) 603 case indexLt: 604 return r.doLt(ctx, f) 605 case indexNe: 606 return r.doNe(ctx, f) 607 case indexIsNull: 608 return r.doIsNull(ctx, f) 609 case indexIsNotNull: 610 return r.doIsNotNull(ctx, f) 611 case indexFalse: 612 return r.doFalse(ctx, f) 613 case indexTrue: 614 return r.doTrue(ctx, f) 615 case indexIntervalOO: 616 return r.doInterval00(ctx, f) 617 case indexIntervalCC: 618 return r.doIntervalCC(ctx, f) 619 case indexIntervalOC: 620 return r.doIntervalOC(ctx, f) 621 case indexIntervalCO: 622 return r.doIntervalCO(ctx, f) 623 default: 624 //dbg("", r.kind) 625 panic("internal error 072") 626 } 627 } 628 629 func (r *indexPlan) explain(w strutil.Formatter) { 630 s := "" 631 if r.kind == indexFalse { 632 s = "!" 633 } 634 w.Format("┌Iterate all rows of table %q using index %q where %s%s", r.src.name, r.xname, s, r.cname) 635 switch r.kind { 636 case indexEq: 637 w.Format(" == %v", value{r.lval}) 638 case indexGe: 639 w.Format(" >= %v", value{r.lval}) 640 case indexGt: 641 w.Format(" > %v", value{r.lval}) 642 case indexLe: 643 w.Format(" <= %v", value{r.hval}) 644 case indexLt: 645 w.Format(" < %v", value{r.hval}) 646 case indexNe: 647 w.Format(" != %v", value{r.lval}) 648 case indexIsNull: 649 w.Format(" IS NULL") 650 case indexIsNotNull: 651 w.Format(" IS NOT NULL") 652 case indexFalse, indexTrue: 653 // nop 654 case indexIntervalOO: 655 w.Format(" > %v && %s < %v", value{r.lval}, r.cname, value{r.hval}) 656 case indexIntervalCC: 657 w.Format(" >= %v && %s <= %v", value{r.lval}, r.cname, value{r.hval}) 658 case indexIntervalCO: 659 w.Format(" >= %v && %s < %v", value{r.lval}, r.cname, value{r.hval}) 660 case indexIntervalOC: 661 w.Format(" > %v && %s <= %v", value{r.lval}, r.cname, value{r.hval}) 662 default: 663 //dbg("", r.kind) 664 panic("internal error 073") 665 } 666 w.Format("\n└Output field names %v\n", qnames(r.fieldNames())) 667 } 668 669 func (r *indexPlan) fieldNames() []string { return r.src.fieldNames() } 670 671 func (r *indexPlan) filterEq(binOp2 int, val interface{}) (plan, []string, error) { 672 switch binOp2 { 673 case eq: 674 if collate1(r.lval, val) == 0 { 675 return r, nil, nil 676 } 677 678 return &nullPlan{r.fieldNames()}, nil, nil 679 case ge: 680 if collate1(r.lval, val) >= 0 { 681 return r, nil, nil 682 } 683 684 return &nullPlan{r.fieldNames()}, nil, nil 685 case '>': 686 if collate1(r.lval, val) > 0 { 687 return r, nil, nil 688 } 689 690 return &nullPlan{r.fieldNames()}, nil, nil 691 case le: 692 if collate1(r.lval, val) <= 0 { 693 return r, nil, nil 694 } 695 696 return &nullPlan{r.fieldNames()}, nil, nil 697 case '<': 698 if collate1(r.lval, val) < 0 { 699 return r, nil, nil 700 } 701 702 return &nullPlan{r.fieldNames()}, nil, nil 703 case neq: 704 if collate1(r.lval, val) != 0 { 705 return r, nil, nil 706 } 707 708 return &nullPlan{r.fieldNames()}, nil, nil 709 } 710 return nil, nil, nil 711 } 712 713 func (r *indexPlan) filterGe(binOp2 int, val interface{}) (plan, []string, error) { 714 switch binOp2 { 715 case eq: 716 if collate1(r.lval, val) <= 0 { 717 r.lval = val 718 r.kind = indexEq 719 return r, nil, nil 720 } 721 722 return &nullPlan{r.fieldNames()}, nil, nil 723 case ge: 724 if collate1(r.lval, val) < 0 { 725 r.lval = val 726 } 727 return r, nil, nil 728 case '>': 729 if collate1(r.lval, val) <= 0 { 730 r.lval = val 731 r.kind = indexGt 732 } 733 return r, nil, nil 734 case le: 735 switch c := collate1(r.lval, val); { 736 case c < 0: 737 r.hval = val 738 r.kind = indexIntervalCC 739 return r, nil, nil 740 case c == 0: 741 r.kind = indexEq 742 return r, nil, nil 743 default: // c > 0 744 return &nullPlan{r.fieldNames()}, nil, nil 745 } 746 case '<': 747 if collate1(r.lval, val) < 0 { 748 r.hval = val 749 r.kind = indexIntervalCO 750 return r, nil, nil 751 } 752 753 return &nullPlan{r.fieldNames()}, nil, nil 754 case neq: 755 switch c := collate1(r.lval, val); { 756 case c < 0: 757 //MAYBE ORed intervals 758 case c == 0: 759 r.kind = indexGt 760 return r, nil, nil 761 default: // c > 0 762 return r, nil, nil 763 } 764 } 765 return nil, nil, nil 766 } 767 768 func (r *indexPlan) filterGt(binOp2 int, val interface{}) (plan, []string, error) { 769 switch binOp2 { 770 case eq: 771 if collate1(r.lval, val) < 0 { 772 r.lval = val 773 r.kind = indexEq 774 return r, nil, nil 775 } 776 777 return &nullPlan{r.fieldNames()}, nil, nil 778 case ge: 779 if collate1(r.lval, val) < 0 { 780 r.lval = val 781 r.kind = indexGe 782 } 783 return r, nil, nil 784 case '>': 785 if collate1(r.lval, val) < 0 { 786 r.lval = val 787 } 788 return r, nil, nil 789 case le: 790 if collate1(r.lval, val) < 0 { 791 r.hval = val 792 r.kind = indexIntervalOC 793 return r, nil, nil 794 } 795 796 return &nullPlan{r.fieldNames()}, nil, nil 797 case '<': 798 if collate1(r.lval, val) < 0 { 799 r.hval = val 800 r.kind = indexIntervalOO 801 return r, nil, nil 802 } 803 804 return &nullPlan{r.fieldNames()}, nil, nil 805 case neq: 806 if collate1(r.lval, val) >= 0 { 807 return r, nil, nil 808 } 809 } 810 return nil, nil, nil 811 } 812 813 func (r *indexPlan) filterLe(binOp2 int, val interface{}) (plan, []string, error) { 814 switch binOp2 { 815 case eq: 816 if collate1(r.hval, val) >= 0 { 817 r.lval = val 818 r.kind = indexEq 819 return r, nil, nil 820 } 821 822 return &nullPlan{r.fieldNames()}, nil, nil 823 case ge: 824 switch c := collate1(r.hval, val); { 825 case c < 0: 826 return &nullPlan{r.fieldNames()}, nil, nil 827 case c == 0: 828 r.lval = val 829 r.kind = indexEq 830 return r, nil, nil 831 default: // c > 0 832 r.lval = val 833 r.kind = indexIntervalCC 834 return r, nil, nil 835 } 836 case '>': 837 if collate1(r.hval, val) > 0 { 838 r.lval = val 839 r.kind = indexIntervalOC 840 return r, nil, nil 841 } 842 843 return &nullPlan{r.fieldNames()}, nil, nil 844 case le: 845 if collate1(r.hval, val) > 0 { 846 r.hval = val 847 } 848 return r, nil, nil 849 case '<': 850 if collate1(r.hval, val) >= 0 { 851 r.hval = val 852 r.kind = indexLt 853 } 854 return r, nil, nil 855 case neq: 856 switch c := collate1(r.hval, val); { 857 case c < 0: 858 return r, nil, nil 859 case c == 0: 860 r.kind = indexLt 861 return r, nil, nil 862 default: // c > 0 863 //bop 864 } 865 } 866 return nil, nil, nil 867 } 868 869 func (r *indexPlan) filterLt(binOp2 int, val interface{}) (plan, []string, error) { 870 switch binOp2 { 871 case eq: 872 if collate1(r.hval, val) > 0 { 873 r.lval = val 874 r.kind = indexEq 875 return r, nil, nil 876 } 877 878 return &nullPlan{r.fieldNames()}, nil, nil 879 case ge: 880 if collate1(r.hval, val) > 0 { 881 r.lval = val 882 r.kind = indexIntervalCO 883 return r, nil, nil 884 } 885 886 return &nullPlan{r.fieldNames()}, nil, nil 887 case '>': 888 if collate1(r.hval, val) > 0 { 889 r.lval = val 890 r.kind = indexIntervalOO 891 return r, nil, nil 892 } 893 894 return &nullPlan{r.fieldNames()}, nil, nil 895 case le: 896 if collate1(r.hval, val) > 0 { 897 r.hval = val 898 r.kind = indexLe 899 } 900 return r, nil, nil 901 case '<': 902 if collate1(r.hval, val) > 0 { 903 r.hval = val 904 } 905 return r, nil, nil 906 case neq: 907 if collate1(r.hval, val) > 0 { 908 return nil, nil, nil 909 } 910 911 return r, nil, nil 912 } 913 return nil, nil, nil 914 } 915 916 func (r *indexPlan) filterCC(binOp2 int, val interface{}) (plan, []string, error) { 917 switch binOp2 { 918 case eq: 919 if collate1(val, r.lval) < 0 || collate1(val, r.hval) > 0 { 920 return &nullPlan{r.fieldNames()}, nil, nil 921 } 922 923 r.lval = val 924 r.kind = indexEq 925 return r, nil, nil 926 case ge: 927 if collate1(val, r.lval) <= 0 { 928 return r, nil, nil 929 } 930 931 switch c := collate1(val, r.hval); { 932 case c < 0: 933 r.lval = val 934 return r, nil, nil 935 case c == 0: 936 r.lval = val 937 r.kind = indexEq 938 return r, nil, nil 939 default: 940 return &nullPlan{r.fieldNames()}, nil, nil 941 } 942 case '>': 943 switch c := collate1(val, r.lval); { 944 case c < 0: 945 return r, nil, nil 946 case c == 0: 947 r.kind = indexIntervalOC 948 return r, nil, nil 949 default: 950 if collate1(val, r.hval) < 0 { 951 r.lval = val 952 r.kind = indexIntervalOC 953 return r, nil, nil 954 } 955 956 return &nullPlan{r.fieldNames()}, nil, nil 957 } 958 case le: 959 switch c := collate1(val, r.lval); { 960 case c < 0: 961 return &nullPlan{r.fieldNames()}, nil, nil 962 case c == 0: 963 r.kind = indexEq 964 return r, nil, nil 965 default: 966 if collate1(val, r.hval) < 0 { 967 r.hval = val 968 } 969 return r, nil, nil 970 } 971 case '<': 972 if collate1(val, r.lval) <= 0 { 973 return &nullPlan{r.fieldNames()}, nil, nil 974 } 975 976 if collate1(val, r.hval) <= 0 { 977 r.hval = val 978 r.kind = indexIntervalCO 979 } 980 return r, nil, nil 981 case neq: 982 switch c := collate1(val, r.lval); { 983 case c < 0: 984 return r, nil, nil 985 case c == 0: 986 r.kind = indexIntervalOC 987 return r, nil, nil 988 default: 989 switch c := collate1(val, r.hval); { 990 case c == 0: 991 r.kind = indexIntervalCO 992 return r, nil, nil 993 case c > 0: 994 return r, nil, nil 995 default: 996 return nil, nil, nil 997 } 998 } 999 } 1000 return nil, nil, nil 1001 } 1002 1003 func (r *indexPlan) filterOC(binOp2 int, val interface{}) (plan, []string, error) { 1004 switch binOp2 { 1005 case eq: 1006 if collate1(val, r.lval) <= 0 || collate1(val, r.hval) > 0 { 1007 return &nullPlan{r.fieldNames()}, nil, nil 1008 } 1009 1010 r.lval = val 1011 r.kind = indexEq 1012 return r, nil, nil 1013 case ge: 1014 if collate1(val, r.lval) <= 0 { 1015 return r, nil, nil 1016 } 1017 1018 switch c := collate1(val, r.hval); { 1019 case c < 0: 1020 r.lval = val 1021 r.kind = indexIntervalCC 1022 return r, nil, nil 1023 case c == 0: 1024 r.lval = val 1025 r.kind = indexEq 1026 return r, nil, nil 1027 default: 1028 return &nullPlan{r.fieldNames()}, nil, nil 1029 } 1030 case '>': 1031 if collate1(val, r.lval) <= 0 { 1032 return r, nil, nil 1033 } 1034 1035 if collate1(val, r.hval) < 0 { 1036 r.lval = val 1037 return r, nil, nil 1038 } 1039 1040 return &nullPlan{r.fieldNames()}, nil, nil 1041 case le: 1042 if collate1(val, r.lval) <= 0 { 1043 return &nullPlan{r.fieldNames()}, nil, nil 1044 } 1045 1046 if collate1(val, r.hval) < 0 { 1047 r.hval = val 1048 } 1049 return r, nil, nil 1050 case '<': 1051 if collate1(val, r.lval) <= 0 { 1052 return &nullPlan{r.fieldNames()}, nil, nil 1053 } 1054 1055 switch c := collate1(val, r.hval); { 1056 case c < 0: 1057 r.hval = val 1058 r.kind = indexIntervalOO 1059 case c == 0: 1060 r.kind = indexIntervalOO 1061 } 1062 return r, nil, nil 1063 case neq: 1064 if collate1(val, r.lval) <= 0 { 1065 return r, nil, nil 1066 } 1067 1068 switch c := collate1(val, r.hval); { 1069 case c < 0: 1070 return nil, nil, nil 1071 case c == 0: 1072 r.kind = indexIntervalOO 1073 return r, nil, nil 1074 default: 1075 return r, nil, nil 1076 } 1077 } 1078 return nil, nil, nil 1079 } 1080 1081 func (r *indexPlan) filterOO(binOp2 int, val interface{}) (plan, []string, error) { 1082 switch binOp2 { 1083 case eq: 1084 if collate1(val, r.lval) <= 0 || collate1(val, r.hval) >= 0 { 1085 return &nullPlan{r.fieldNames()}, nil, nil 1086 } 1087 1088 r.lval = val 1089 r.kind = indexEq 1090 return r, nil, nil 1091 case ge: 1092 if collate1(val, r.lval) <= 0 { 1093 return r, nil, nil 1094 } 1095 1096 if collate1(val, r.hval) < 0 { 1097 r.lval = val 1098 r.kind = indexIntervalCO 1099 return r, nil, nil 1100 } 1101 1102 return &nullPlan{r.fieldNames()}, nil, nil 1103 case '>': 1104 if collate1(val, r.lval) <= 0 { 1105 return r, nil, nil 1106 } 1107 1108 if collate1(val, r.hval) < 0 { 1109 r.lval = val 1110 return r, nil, nil 1111 } 1112 1113 return &nullPlan{r.fieldNames()}, nil, nil 1114 case le: 1115 if collate1(val, r.lval) <= 0 { 1116 return &nullPlan{r.fieldNames()}, nil, nil 1117 } 1118 1119 if collate1(val, r.hval) < 0 { 1120 r.hval = val 1121 r.kind = indexIntervalOC 1122 } 1123 return r, nil, nil 1124 case '<': 1125 if collate1(val, r.lval) <= 0 { 1126 return &nullPlan{r.fieldNames()}, nil, nil 1127 } 1128 1129 if collate1(val, r.hval) < 0 { 1130 r.hval = val 1131 } 1132 return r, nil, nil 1133 case neq: 1134 if collate1(val, r.lval) <= 0 || collate1(val, r.hval) >= 0 { 1135 return r, nil, nil 1136 } 1137 1138 return nil, nil, nil 1139 } 1140 return nil, nil, nil 1141 } 1142 1143 func (r *indexPlan) filterCO(binOp2 int, val interface{}) (plan, []string, error) { 1144 switch binOp2 { 1145 case eq: 1146 if collate1(val, r.lval) < 0 || collate1(val, r.hval) >= 0 { 1147 return &nullPlan{r.fieldNames()}, nil, nil 1148 } 1149 1150 r.lval = val 1151 r.kind = indexEq 1152 return r, nil, nil 1153 case ge: 1154 if collate1(val, r.lval) <= 0 { 1155 return r, nil, nil 1156 } 1157 1158 if collate1(val, r.hval) < 0 { 1159 r.lval = val 1160 return r, nil, nil 1161 } 1162 1163 return &nullPlan{r.fieldNames()}, nil, nil 1164 case '>': 1165 switch c := collate1(val, r.lval); { 1166 case c < 0: 1167 return r, nil, nil 1168 case c == 0: 1169 r.kind = indexIntervalOO 1170 return r, nil, nil 1171 default: 1172 if collate1(val, r.hval) < 0 { 1173 r.lval = val 1174 r.kind = indexIntervalOO 1175 return r, nil, nil 1176 } 1177 1178 return &nullPlan{r.fieldNames()}, nil, nil 1179 } 1180 case le: 1181 switch c := collate1(val, r.lval); { 1182 case c < 0: 1183 return &nullPlan{r.fieldNames()}, nil, nil 1184 case c == 0: 1185 r.kind = indexEq 1186 return r, nil, nil 1187 default: 1188 if collate1(val, r.hval) < 0 { 1189 r.hval = val 1190 r.kind = indexIntervalCC 1191 } 1192 return r, nil, nil 1193 } 1194 case '<': 1195 if collate1(val, r.lval) <= 0 { 1196 return &nullPlan{r.fieldNames()}, nil, nil 1197 } 1198 1199 if collate1(val, r.hval) < 0 { 1200 r.hval = val 1201 } 1202 return r, nil, nil 1203 case neq: 1204 switch c := collate1(val, r.lval); { 1205 case c < 0: 1206 return r, nil, nil 1207 case c == 0: 1208 r.kind = indexIntervalOO 1209 return r, nil, nil 1210 default: 1211 if collate1(val, r.hval) < 0 { 1212 return nil, nil, nil 1213 } 1214 1215 return r, nil, nil 1216 } 1217 } 1218 return nil, nil, nil 1219 } 1220 1221 func (r *indexPlan) filterNe(binOp2 int, val interface{}) (plan, []string, error) { 1222 switch binOp2 { 1223 case eq: 1224 if collate1(val, r.lval) != 0 { 1225 r.lval = val 1226 r.kind = indexEq 1227 return r, nil, nil 1228 } 1229 1230 return &nullPlan{r.fieldNames()}, nil, nil 1231 case ge: 1232 switch c := collate1(val, r.lval); { 1233 case c < 0: 1234 return nil, nil, nil //TODO 1235 case c == 0: 1236 r.kind = indexGt 1237 return r, nil, nil 1238 default: 1239 r.lval = val 1240 r.kind = indexGe 1241 return r, nil, nil 1242 } 1243 case '>': 1244 if collate1(val, r.lval) < 0 { 1245 return nil, nil, nil //TODO 1246 } 1247 1248 r.lval = val 1249 r.kind = indexGt 1250 return r, nil, nil 1251 case le: 1252 switch c := collate1(val, r.lval); { 1253 case c < 0: 1254 r.hval = val 1255 r.kind = indexLe 1256 return r, nil, nil 1257 case c == 0: 1258 r.kind = indexLt 1259 return r, nil, nil 1260 default: 1261 return nil, nil, nil //TODO 1262 } 1263 case '<': 1264 if collate1(val, r.lval) <= 0 { 1265 r.hval = val 1266 r.kind = indexLt 1267 return r, nil, nil 1268 } 1269 1270 return nil, nil, nil //TODO 1271 case neq: 1272 if collate1(val, r.lval) == 0 { 1273 return r, nil, nil 1274 } 1275 1276 return nil, nil, nil 1277 } 1278 return nil, nil, nil 1279 } 1280 1281 func (r *indexPlan) filter(expr expression) (plan, []string, error) { 1282 switch x := expr.(type) { 1283 case *binaryOperation: 1284 ok, cname, val, err := x.isIdentRelOpVal() 1285 if err != nil { 1286 return nil, nil, err 1287 } 1288 1289 if !ok || r.cname != cname { 1290 break 1291 } 1292 1293 if val, err = typeCheck1(val, findCol(r.src.cols, cname)); err != nil { 1294 return nil, nil, err 1295 } 1296 1297 switch r.kind { 1298 case indexEq: // [L] 1299 return r.filterEq(x.op, val) 1300 case indexGe: // [L, ...) 1301 return r.filterGe(x.op, val) 1302 case indexGt: // (L, ...) 1303 return r.filterGt(x.op, val) 1304 case indexIntervalCC: // [L, H] 1305 return r.filterCC(x.op, val) 1306 case indexIntervalCO: // [L, H) 1307 return r.filterCO(x.op, val) 1308 case indexIntervalOC: // (L, H] 1309 return r.filterOC(x.op, val) 1310 case indexIntervalOO: // (L, H) 1311 return r.filterOO(x.op, val) 1312 case indexLe: // (..., H] 1313 return r.filterLe(x.op, val) 1314 case indexLt: // (..., H) 1315 return r.filterLt(x.op, val) 1316 case indexNe: // (L) 1317 return r.filterNe(x.op, val) 1318 } 1319 case *ident: 1320 cname := x.s 1321 if r.cname != cname { 1322 break 1323 } 1324 1325 switch r.kind { 1326 case indexFalse: // [false] 1327 return &nullPlan{r.fieldNames()}, nil, nil 1328 case indexTrue: // [true] 1329 return r, nil, nil 1330 } 1331 case *unaryOperation: 1332 if x.op != '!' { 1333 break 1334 } 1335 1336 operand, ok := x.v.(*ident) 1337 if !ok { 1338 break 1339 } 1340 1341 cname := operand.s 1342 if r.cname != cname { 1343 break 1344 } 1345 1346 switch r.kind { 1347 case indexFalse: // [false] 1348 return r, nil, nil 1349 case indexTrue: // [true] 1350 return &nullPlan{r.fieldNames()}, nil, nil 1351 } 1352 } 1353 1354 return nil, nil, nil 1355 } 1356 1357 func (r *indexPlan) hasID() bool { return true } 1358 1359 type explainDefaultPlan struct { 1360 s stmt 1361 } 1362 1363 func (r *explainDefaultPlan) hasID() bool { return false } 1364 1365 func (r *explainDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (more bool, err error)) error { 1366 var buf bytes.Buffer 1367 switch x := r.s.(type) { 1368 default: 1369 w := strutil.IndentFormatter(&buf, "│ ") 1370 x.explain(ctx, w) 1371 } 1372 1373 a := bytes.Split(buf.Bytes(), []byte{'\n'}) 1374 for _, v := range a[:len(a)-1] { 1375 if more, err := f(nil, []interface{}{string(v)}); !more || err != nil { 1376 return err 1377 } 1378 } 1379 return nil 1380 } 1381 1382 func (r *explainDefaultPlan) explain(w strutil.Formatter) { 1383 return 1384 } 1385 1386 func (r *explainDefaultPlan) fieldNames() []string { 1387 return []string{""} 1388 } 1389 1390 func (r *explainDefaultPlan) filter(expr expression) (plan, []string, error) { 1391 return nil, nil, nil 1392 } 1393 1394 type filterDefaultPlan struct { 1395 plan 1396 expr expression 1397 is []string 1398 } 1399 1400 func (r *filterDefaultPlan) hasID() bool { return r.plan.hasID() } 1401 1402 func (r *filterDefaultPlan) explain(w strutil.Formatter) { 1403 r.plan.explain(w) 1404 w.Format("┌Filter on %v\n", r.expr) 1405 if len(r.is) != 0 { 1406 w.Format("│Possibly useful indices\n") 1407 m := map[string]bool{} 1408 for _, v := range r.is { 1409 if !m[v] { 1410 m[v] = true 1411 n := "" 1412 for _, r := range v { 1413 if r >= '0' && r <= '9' || r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r == '_' { 1414 n += string(r) 1415 continue 1416 } 1417 1418 n += "_" 1419 } 1420 for strings.Contains(n, "__") { 1421 n = strings.Replace(n, "__", "_", -1) 1422 } 1423 for strings.HasSuffix(n, "_") { 1424 n = n[:len(n)-1] 1425 } 1426 w.Format("│CREATE INDEX x%s ON %s;\n", n, v) 1427 } 1428 } 1429 } 1430 w.Format("└Output field names %v\n", qnames(r.plan.fieldNames())) 1431 } 1432 1433 func (r *filterDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) (err error) { 1434 m := map[interface{}]interface{}{} 1435 fields := r.plan.fieldNames() 1436 return r.plan.do(ctx, func(rid interface{}, data []interface{}) (bool, error) { 1437 for i, v := range fields { 1438 m[v] = data[i] 1439 } 1440 m["$id"] = rid 1441 val, err := r.expr.eval(ctx, m) 1442 if err != nil { 1443 return false, err 1444 } 1445 1446 if val == nil { 1447 return true, nil 1448 } 1449 1450 x, ok := val.(bool) 1451 if !ok { 1452 return false, fmt.Errorf("invalid boolean expression %s (value of type %T)", val, val) 1453 } 1454 1455 if !x { 1456 return true, nil 1457 } 1458 1459 return f(rid, data) 1460 }) 1461 } 1462 1463 type crossJoinDefaultPlan struct { 1464 rsets []plan 1465 names []string 1466 fields []string 1467 } 1468 1469 func (r *crossJoinDefaultPlan) hasID() bool { return false } 1470 1471 func (r *crossJoinDefaultPlan) explain(w strutil.Formatter) { 1472 w.Format("┌Compute Cartesian product of%i\n") 1473 for i, v := range r.rsets { 1474 sel := !isTableOrIndex(v) 1475 if sel { 1476 w.Format("┌Iterate all rows of virtual table %q%i\n", r.names[i]) 1477 } 1478 v.explain(w) 1479 if sel { 1480 w.Format("%u└Output field names %v\n", qnames(v.fieldNames())) 1481 } 1482 } 1483 w.Format("%u└Output field names %v\n", qnames(r.fields)) 1484 } 1485 1486 func (r *crossJoinDefaultPlan) filter(expr expression) (plan, []string, error) { 1487 var is []string 1488 for i, v := range r.names { 1489 e2, err := expr.clone(nil, v) 1490 if err != nil { 1491 return nil, nil, err 1492 } 1493 1494 p2, is2, err := r.rsets[i].filter(e2) 1495 is = append(is, is2...) 1496 if err != nil { 1497 return nil, nil, err 1498 } 1499 1500 if p2 != nil { 1501 r.rsets[i] = p2 1502 return r, is, nil 1503 } 1504 } 1505 return nil, is, nil 1506 } 1507 1508 func (r *crossJoinDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) error { 1509 if len(r.rsets) == 1 { 1510 return r.rsets[0].do(ctx, f) 1511 } 1512 1513 ids := map[string]interface{}{} 1514 var g func([]interface{}, []plan, int) error 1515 g = func(prefix []interface{}, rsets []plan, x int) (err error) { 1516 return rsets[0].do(ctx, func(id interface{}, in []interface{}) (bool, error) { 1517 ids[r.names[x]] = id 1518 if len(rsets) > 1 { 1519 return true, g(append(prefix, in...), rsets[1:], x+1) 1520 } 1521 1522 return f(ids, append(prefix, in...)) 1523 }) 1524 } 1525 return g(nil, r.rsets, 0) 1526 } 1527 1528 func (r *crossJoinDefaultPlan) fieldNames() []string { return r.fields } 1529 1530 type distinctDefaultPlan struct { 1531 src plan 1532 fields []string 1533 } 1534 1535 func (r *distinctDefaultPlan) hasID() bool { return false } 1536 1537 func (r *distinctDefaultPlan) explain(w strutil.Formatter) { 1538 r.src.explain(w) 1539 w.Format("┌Compute distinct rows\n└Output field names %v\n", r.fields) 1540 } 1541 1542 func (r *distinctDefaultPlan) filter(expr expression) (plan, []string, error) { 1543 return nil, nil, nil 1544 } 1545 1546 func (r *distinctDefaultPlan) fieldNames() []string { return r.fields } 1547 1548 func (r *distinctDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) (err error) { 1549 t, err := ctx.db.store.CreateTemp(true) 1550 if err != nil { 1551 return 1552 } 1553 1554 defer func() { 1555 if derr := t.Drop(); derr != nil && err == nil { 1556 err = derr 1557 } 1558 }() 1559 1560 if err = r.src.do(ctx, func(id interface{}, in []interface{}) (bool, error) { 1561 if err = t.Set(in, nil); err != nil { 1562 return false, err 1563 } 1564 1565 return true, nil 1566 }); err != nil { 1567 return 1568 } 1569 1570 var data []interface{} 1571 more := true 1572 it, err := t.SeekFirst() 1573 for more && err == nil { 1574 data, _, err = it.Next() 1575 if err != nil { 1576 break 1577 } 1578 1579 more, err = f(nil, data) 1580 } 1581 return noEOF(err) 1582 } 1583 1584 type groupByDefaultPlan struct { 1585 colNames []string 1586 src plan 1587 fields []string 1588 } 1589 1590 func (r *groupByDefaultPlan) hasID() bool { return false } 1591 1592 func (r *groupByDefaultPlan) explain(w strutil.Formatter) { 1593 r.src.explain(w) 1594 switch { 1595 case len(r.colNames) == 0: //TODO this case should not exist for this plan, should become tableDefaultPlan 1596 w.Format("┌Group by distinct rows") 1597 default: 1598 w.Format("┌Group by") 1599 for _, v := range r.colNames { 1600 w.Format(" %s,", v) 1601 } 1602 } 1603 w.Format("\n└Output field names %v\n", qnames(r.fields)) 1604 } 1605 1606 func (r *groupByDefaultPlan) filter(expr expression) (plan, []string, error) { 1607 return nil, nil, nil 1608 } 1609 1610 func (r *groupByDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) (err error) { 1611 t, err := ctx.db.store.CreateTemp(true) 1612 if err != nil { 1613 return 1614 } 1615 1616 defer func() { 1617 if derr := t.Drop(); derr != nil && err == nil { 1618 err = derr 1619 } 1620 }() 1621 1622 var gcols []*col 1623 var cols []*col 1624 m := map[string]int{} 1625 for i, v := range r.src.fieldNames() { 1626 m[v] = i 1627 } 1628 for _, c := range r.colNames { 1629 i, ok := m[c] 1630 if !ok { 1631 return fmt.Errorf("unknown field %s", c) 1632 } 1633 1634 gcols = append(gcols, &col{name: c, index: i}) 1635 } 1636 k := make([]interface{}, len(r.colNames)) //TODO optimize when len(r.cols) == 0, should become tableDefaultPlan 1637 if err = r.src.do(ctx, func(rid interface{}, in []interface{}) (more bool, err error) { 1638 infer(in, &cols) 1639 for i, c := range gcols { 1640 k[i] = in[c.index] 1641 } 1642 h0, err := t.Get(k) 1643 if err != nil { 1644 return false, err 1645 } 1646 1647 var h int64 1648 if len(h0) != 0 { 1649 h, _ = h0[0].(int64) 1650 } 1651 nh, err := t.Create(append([]interface{}{h, nil}, in...)...) 1652 if err != nil { 1653 return false, err 1654 } 1655 1656 for i, c := range gcols { 1657 k[i] = in[c.index] 1658 } 1659 err = t.Set(k, []interface{}{nh}) 1660 if err != nil { 1661 return false, err 1662 } 1663 1664 return true, nil 1665 }); err != nil { 1666 return 1667 } 1668 1669 for i, v := range r.src.fieldNames()[:len(cols)] { 1670 cols[i].name = v 1671 cols[i].index = i 1672 } 1673 if more, err := f(nil, []interface{}{t, cols}); !more || err != nil { 1674 return err 1675 } 1676 1677 it, err := t.SeekFirst() 1678 more := true 1679 var data []interface{} 1680 for more && err == nil { 1681 if _, data, err = it.Next(); err != nil { 1682 break 1683 } 1684 1685 more, err = f(nil, data) 1686 } 1687 return noEOF(err) 1688 } 1689 1690 func (r *groupByDefaultPlan) fieldNames() []string { return r.fields } 1691 1692 type selectIndexDefaultPlan struct { 1693 nm string 1694 x interface{} 1695 } 1696 1697 func (r *selectIndexDefaultPlan) hasID() bool { return false } 1698 1699 func (r *selectIndexDefaultPlan) explain(w strutil.Formatter) { 1700 w.Format("┌Iterate all values of index %q\n└Output field names N/A\n", r.nm) 1701 } 1702 1703 func (r *selectIndexDefaultPlan) filter(expr expression) (plan, []string, error) { 1704 return nil, nil, nil 1705 } 1706 1707 func (r *selectIndexDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) (err error) { 1708 var x btreeIndex 1709 switch ix := r.x.(type) { 1710 case *indexedCol: 1711 x = ix.x 1712 case *index2: 1713 x = ix.x 1714 default: 1715 panic("internal error 007") 1716 } 1717 1718 en, err := x.SeekFirst() 1719 if err != nil { 1720 return noEOF(err) 1721 } 1722 1723 var id int64 1724 for { 1725 k, _, err := en.Next() 1726 if err != nil { 1727 return noEOF(err) 1728 } 1729 1730 id++ 1731 if more, err := f(id, k); !more || err != nil { 1732 return err 1733 } 1734 } 1735 } 1736 1737 func (r *selectIndexDefaultPlan) fieldNames() []string { 1738 return []string{r.nm} 1739 } 1740 1741 type limitDefaultPlan struct { 1742 expr expression 1743 src plan 1744 fields []string 1745 } 1746 1747 func (r *limitDefaultPlan) hasID() bool { return r.src.hasID() } 1748 1749 func (r *limitDefaultPlan) explain(w strutil.Formatter) { 1750 r.src.explain(w) 1751 w.Format("┌Pass first %v records\n└Output field names %v\n", r.expr, r.fields) 1752 } 1753 1754 func (r *limitDefaultPlan) filter(expr expression) (plan, []string, error) { 1755 return nil, nil, nil 1756 } 1757 1758 func (r *limitDefaultPlan) fieldNames() []string { return r.fields } 1759 1760 func (r *limitDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (more bool, err error)) (err error) { 1761 m := map[interface{}]interface{}{} 1762 var eval bool 1763 var lim uint64 1764 return r.src.do(ctx, func(rid interface{}, in []interface{}) (more bool, err error) { 1765 if !eval { 1766 for i, fld := range r.fields { 1767 if fld != "" { 1768 m[fld] = in[i] 1769 } 1770 } 1771 m["$id"] = rid 1772 val, err := r.expr.eval(ctx, m) 1773 if err != nil { 1774 return false, err 1775 } 1776 1777 if val == nil { 1778 return true, nil 1779 } 1780 1781 if lim, err = limOffExpr(val); err != nil { 1782 return false, err 1783 } 1784 1785 eval = true 1786 } 1787 switch lim { 1788 case 0: 1789 return false, nil 1790 default: 1791 lim-- 1792 return f(rid, in) 1793 } 1794 }) 1795 } 1796 1797 type offsetDefaultPlan struct { 1798 expr expression 1799 src plan 1800 fields []string 1801 } 1802 1803 func (r *offsetDefaultPlan) hasID() bool { return r.src.hasID() } 1804 1805 func (r *offsetDefaultPlan) explain(w strutil.Formatter) { 1806 r.src.explain(w) 1807 w.Format("┌Skip first %v records\n└Output field names %v\n", r.expr, qnames(r.fields)) 1808 } 1809 1810 func (r *offsetDefaultPlan) filter(expr expression) (plan, []string, error) { 1811 return nil, nil, nil 1812 } 1813 1814 func (r *offsetDefaultPlan) fieldNames() []string { return r.fields } 1815 1816 func (r *offsetDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) error { 1817 m := map[interface{}]interface{}{} 1818 var eval bool 1819 var off uint64 1820 return r.src.do(ctx, func(rid interface{}, in []interface{}) (bool, error) { 1821 if !eval { 1822 for i, fld := range r.fields { 1823 if fld != "" { 1824 m[fld] = in[i] 1825 } 1826 } 1827 m["$id"] = rid 1828 val, err := r.expr.eval(ctx, m) 1829 if err != nil { 1830 return false, err 1831 } 1832 1833 if val == nil { 1834 return true, nil 1835 } 1836 1837 if off, err = limOffExpr(val); err != nil { 1838 return false, err 1839 } 1840 1841 eval = true 1842 } 1843 if off > 0 { 1844 off-- 1845 return true, nil 1846 } 1847 1848 return f(rid, in) 1849 }) 1850 } 1851 1852 type orderByDefaultPlan struct { 1853 asc bool 1854 by []expression 1855 src plan 1856 fields []string 1857 } 1858 1859 func (r *orderByDefaultPlan) hasID() bool { return r.src.hasID() } 1860 1861 func (r *orderByDefaultPlan) explain(w strutil.Formatter) { 1862 r.src.explain(w) 1863 w.Format("┌Order%s by", map[bool]string{false: " descending"}[r.asc]) 1864 for _, v := range r.by { 1865 w.Format(" %s,", v) 1866 } 1867 w.Format("\n└Output field names %v\n", qnames(r.fields)) 1868 } 1869 1870 func (r *orderByDefaultPlan) filter(expr expression) (plan, []string, error) { 1871 return nil, nil, nil 1872 } 1873 1874 func (r *orderByDefaultPlan) fieldNames() []string { return r.fields } 1875 1876 func (r *orderByDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) (err error) { 1877 t, err := ctx.db.store.CreateTemp(r.asc) 1878 if err != nil { 1879 return 1880 } 1881 1882 defer func() { 1883 if derr := t.Drop(); derr != nil && err == nil { 1884 err = derr 1885 } 1886 }() 1887 1888 m := map[interface{}]interface{}{} 1889 flds := r.fields 1890 k := make([]interface{}, len(r.by)+1) 1891 id := int64(-1) 1892 if err = r.src.do(ctx, func(rid interface{}, in []interface{}) (bool, error) { 1893 id++ 1894 for i, fld := range flds { 1895 if fld != "" { 1896 m[fld] = in[i] 1897 } 1898 } 1899 m["$id"] = rid 1900 for i, expr := range r.by { 1901 val, err := expr.eval(ctx, m) 1902 if err != nil { 1903 return false, err 1904 } 1905 1906 if val != nil { 1907 val, ordered, err := isOrderedType(val) 1908 if err != nil { 1909 return false, err 1910 } 1911 1912 if !ordered { 1913 return false, fmt.Errorf("cannot order by %v (type %T)", val, val) 1914 1915 } 1916 } 1917 1918 k[i] = val 1919 } 1920 k[len(r.by)] = id 1921 if err = t.Set(k, in); err != nil { 1922 return false, err 1923 } 1924 1925 return true, nil 1926 }); err != nil { 1927 return 1928 } 1929 1930 it, err := t.SeekFirst() 1931 if err != nil { 1932 return noEOF(err) 1933 } 1934 1935 var data []interface{} 1936 more := true 1937 for more && err == nil { 1938 if _, data, err = it.Next(); err != nil { 1939 break 1940 } 1941 1942 more, err = f(nil, data) 1943 } 1944 return noEOF(err) 1945 } 1946 1947 type selectFieldsDefaultPlan struct { 1948 flds []*fld 1949 src plan 1950 fields []string 1951 } 1952 1953 func (r *selectFieldsDefaultPlan) hasID() bool { return r.src.hasID() } 1954 1955 func (r *selectFieldsDefaultPlan) explain(w strutil.Formatter) { 1956 //TODO check for non existing fields 1957 r.src.explain(w) 1958 w.Format("┌Evaluate") 1959 for _, v := range r.flds { 1960 w.Format(" %s as %s,", v.expr, fmt.Sprintf("%q", v.name)) 1961 } 1962 w.Format("\n└Output field names %v\n", qnames(r.fields)) 1963 } 1964 1965 func (r *selectFieldsDefaultPlan) filter(expr expression) (plan, []string, error) { 1966 return nil, nil, nil 1967 } 1968 1969 func (r *selectFieldsDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) error { 1970 fields := r.src.fieldNames() 1971 m := map[interface{}]interface{}{} 1972 return r.src.do(ctx, func(rid interface{}, in []interface{}) (bool, error) { 1973 for i, nm := range fields { 1974 if nm != "" { 1975 m[nm] = in[i] 1976 } 1977 } 1978 m["$id"] = rid 1979 out := make([]interface{}, len(r.flds)) 1980 for i, fld := range r.flds { 1981 var err error 1982 if out[i], err = fld.expr.eval(ctx, m); err != nil { 1983 return false, err 1984 } 1985 } 1986 return f(rid, out) 1987 }) 1988 } 1989 1990 func (r *selectFieldsDefaultPlan) fieldNames() []string { return r.fields } 1991 1992 type selectFieldsGroupPlan struct { 1993 flds []*fld 1994 src *groupByDefaultPlan 1995 fields []string 1996 } 1997 1998 func (r *selectFieldsGroupPlan) hasID() bool { return false } 1999 2000 func (r *selectFieldsGroupPlan) explain(w strutil.Formatter) { 2001 //TODO check for non existing fields 2002 r.src.explain(w) 2003 w.Format("┌Evaluate") 2004 for _, v := range r.flds { 2005 w.Format(" %s as %s,", v.expr, fmt.Sprintf("%q", v.name)) 2006 } 2007 w.Format("\n└Output field names %v\n", qnames(r.fields)) 2008 } 2009 2010 func (r *selectFieldsGroupPlan) fieldNames() []string { return r.fields } 2011 2012 func (r *selectFieldsGroupPlan) filter(expr expression) (plan, []string, error) { 2013 return nil, nil, nil 2014 } 2015 2016 func (r *selectFieldsGroupPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) error { 2017 var t temp 2018 var cols []*col 2019 var err error 2020 out := make([]interface{}, len(r.flds)) 2021 ok := false 2022 rows := false 2023 if err = r.src.do(ctx, func(rid interface{}, in []interface{}) (bool, error) { 2024 if ok { 2025 h := in[0].(int64) 2026 m := map[interface{}]interface{}{} 2027 for h != 0 { 2028 in, err = t.Read(nil, h, cols...) 2029 if err != nil { 2030 return false, err 2031 } 2032 2033 rec := in[2:] 2034 for i, c := range cols { 2035 if nm := c.name; nm != "" { 2036 m[nm] = rec[i] 2037 } 2038 } 2039 m["$id"] = rid 2040 for _, fld := range r.flds { 2041 if _, err = fld.expr.eval(ctx, m); err != nil { 2042 return false, err 2043 } 2044 } 2045 2046 h = in[0].(int64) 2047 } 2048 m["$agg"] = true 2049 for i, fld := range r.flds { 2050 if out[i], err = fld.expr.eval(ctx, m); err != nil { 2051 return false, err 2052 } 2053 } 2054 rows = true 2055 return f(nil, out) 2056 } 2057 2058 ok = true 2059 t = in[0].(temp) 2060 cols = in[1].([]*col) 2061 if len(r.flds) == 0 { // SELECT * 2062 r.flds = make([]*fld, len(cols)) 2063 for i, v := range cols { 2064 r.flds[i] = &fld{expr: &ident{v.name}, name: v.name} 2065 } 2066 out = make([]interface{}, len(r.flds)) 2067 } 2068 return true, nil 2069 }); err != nil { 2070 return err 2071 } 2072 2073 if rows { 2074 return nil 2075 } 2076 2077 m := map[interface{}]interface{}{"$agg0": true} // aggregate empty record set 2078 for i, fld := range r.flds { 2079 if out[i], err = fld.expr.eval(ctx, m); err != nil { 2080 return err 2081 } 2082 } 2083 _, err = f(nil, out) 2084 2085 return err 2086 } 2087 2088 type sysColumnDefaultPlan struct{} 2089 2090 func (r *sysColumnDefaultPlan) hasID() bool { return false } 2091 2092 func (r *sysColumnDefaultPlan) explain(w strutil.Formatter) { 2093 w.Format("┌Iterate all rows of table \"__Column\"\n└Output field names %v\n", qnames(r.fieldNames())) 2094 } 2095 2096 func (r *sysColumnDefaultPlan) filter(expr expression) (plan, []string, error) { 2097 return nil, nil, nil 2098 } 2099 2100 func (r *sysColumnDefaultPlan) fieldNames() []string { 2101 return []string{"TableName", "Ordinal", "Name", "Type"} 2102 } 2103 2104 func (r *sysColumnDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) error { 2105 rec := make([]interface{}, 4) 2106 di, err := ctx.db.info() 2107 if err != nil { 2108 return err 2109 } 2110 2111 var id int64 2112 for _, ti := range di.Tables { 2113 rec[0] = ti.Name 2114 var ix int64 2115 for _, ci := range ti.Columns { 2116 ix++ 2117 rec[1] = ix 2118 rec[2] = ci.Name 2119 rec[3] = ci.Type.String() 2120 id++ 2121 if more, err := f(id, rec); !more || err != nil { 2122 return err 2123 } 2124 } 2125 } 2126 return nil 2127 } 2128 2129 type sysIndexDefaultPlan struct{} 2130 2131 func (r *sysIndexDefaultPlan) hasID() bool { return false } 2132 2133 func (r *sysIndexDefaultPlan) explain(w strutil.Formatter) { 2134 w.Format("┌Iterate all rows of table \"__Index\"\n└Output field names %v\n", qnames(r.fieldNames())) 2135 } 2136 2137 func (r *sysIndexDefaultPlan) filter(expr expression) (plan, []string, error) { 2138 return nil, nil, nil 2139 } 2140 2141 func (r *sysIndexDefaultPlan) fieldNames() []string { 2142 return []string{"TableName", "ColumnName", "Name", "IsUnique"} 2143 } 2144 2145 func (r *sysIndexDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) error { 2146 rec := make([]interface{}, 4) 2147 di, err := ctx.db.info() 2148 if err != nil { 2149 return err 2150 } 2151 2152 var id int64 2153 for _, xi := range di.Indices { 2154 rec[0] = xi.Table 2155 rec[1] = xi.Column 2156 rec[2] = xi.Name 2157 rec[3] = xi.Unique 2158 id++ 2159 if more, err := f(id, rec); !more || err != nil { 2160 return err 2161 } 2162 } 2163 return nil 2164 } 2165 2166 type sysTableDefaultPlan struct{} 2167 2168 func (r *sysTableDefaultPlan) hasID() bool { return false } 2169 2170 func (r *sysTableDefaultPlan) explain(w strutil.Formatter) { 2171 w.Format("┌Iterate all rows of table \"__Table\"\n└Output field names %v\n", qnames(r.fieldNames())) 2172 } 2173 2174 func (r *sysTableDefaultPlan) filter(expr expression) (plan, []string, error) { 2175 return nil, nil, nil 2176 } 2177 2178 func (r *sysTableDefaultPlan) fieldNames() []string { return []string{"Name", "Schema"} } 2179 2180 func (r *sysTableDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) error { 2181 rec := make([]interface{}, 2) 2182 di, err := ctx.db.info() 2183 if err != nil { 2184 return err 2185 } 2186 2187 var id int64 2188 for _, ti := range di.Tables { 2189 rec[0] = ti.Name 2190 a := []string{} 2191 for _, ci := range ti.Columns { 2192 s := "" 2193 if ci.NotNull { 2194 s += " NOT NULL" 2195 } 2196 if c := ci.Constraint; c != "" { 2197 s += " " + c 2198 } 2199 if d := ci.Default; d != "" { 2200 s += " DEFAULT " + d 2201 } 2202 a = append(a, fmt.Sprintf("%s %s%s", ci.Name, ci.Type, s)) 2203 } 2204 rec[1] = fmt.Sprintf("CREATE TABLE %s (%s);", ti.Name, strings.Join(a, ", ")) 2205 id++ 2206 if more, err := f(id, rec); !more || err != nil { 2207 return err 2208 } 2209 } 2210 return nil 2211 } 2212 2213 type tableNilPlan struct { 2214 t *table 2215 } 2216 2217 func (r *tableNilPlan) hasID() bool { return true } 2218 2219 func (r *tableNilPlan) explain(w strutil.Formatter) { 2220 w.Format("┌Iterate all rows of table %q\n└Output field names %v\n", r.t.name, qnames(r.fieldNames())) 2221 } 2222 2223 func (r *tableNilPlan) fieldNames() []string { return []string{} } 2224 2225 func (r *tableNilPlan) filter(expr expression) (plan, []string, error) { 2226 return nil, nil, nil 2227 } 2228 2229 func (r *tableNilPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (bool, error)) (err error) { 2230 t := r.t 2231 h := t.head 2232 cols := t.cols 2233 for h > 0 { 2234 rec, err := t.store.Read(nil, h, cols...) // 0:next, 1:id, 2...: data 2235 if err != nil { 2236 return err 2237 } 2238 2239 if m, err := f(rec[1], nil); !m || err != nil { 2240 return err 2241 } 2242 2243 h = rec[0].(int64) // next 2244 } 2245 return nil 2246 } 2247 2248 type tableDefaultPlan struct { 2249 t *table 2250 fields []string 2251 } 2252 2253 func (r *tableDefaultPlan) hasID() bool { return true } 2254 2255 func (r *tableDefaultPlan) explain(w strutil.Formatter) { 2256 w.Format("┌Iterate all rows of table %q\n└Output field names %v\n", r.t.name, qnames(r.fields)) 2257 } 2258 2259 func (r *tableDefaultPlan) filterBinOp(x *binaryOperation) (plan, []string, error) { 2260 ok, cn, rval, err := x.isIdentRelOpVal() 2261 if err != nil { 2262 return nil, nil, err 2263 } 2264 2265 if !ok { 2266 return nil, nil, nil 2267 } 2268 2269 t := r.t 2270 c, ix := t.findIndexByColName(cn) 2271 if ix == nil { // Column cn has no index. 2272 return nil, []string{fmt.Sprintf("%s(%s)", t.name, cn)}, nil 2273 } 2274 2275 if rval, err = typeCheck1(rval, c); err != nil { 2276 return nil, nil, err 2277 } 2278 2279 switch x.op { 2280 case eq: 2281 return &indexPlan{t, cn, ix.name, ix.x, indexEq, rval, rval}, nil, nil 2282 case '<': 2283 return &indexPlan{t, cn, ix.name, ix.x, indexLt, nil, rval}, nil, nil 2284 case le: 2285 return &indexPlan{t, cn, ix.name, ix.x, indexLe, nil, rval}, nil, nil 2286 case ge: 2287 return &indexPlan{t, cn, ix.name, ix.x, indexGe, rval, nil}, nil, nil 2288 case '>': 2289 return &indexPlan{t, cn, ix.name, ix.x, indexGt, rval, nil}, nil, nil 2290 case neq: 2291 return &indexPlan{t, cn, ix.name, ix.x, indexNe, rval, rval}, nil, nil 2292 default: 2293 panic("internal error 069") 2294 } 2295 } 2296 2297 func (r *tableDefaultPlan) filterIdent(x *ident, trueValue bool) (plan, []string, error) { 2298 cn := x.s 2299 t := r.t 2300 for _, v := range t.cols { 2301 if v.name != cn { 2302 continue 2303 } 2304 2305 if v.typ != qBool { 2306 return nil, nil, nil 2307 } 2308 2309 xi := v.index + 1 // 0: id() 2310 if xi >= len(t.indices) { 2311 return nil, nil, nil 2312 } 2313 2314 ix := t.indices[xi] 2315 if ix == nil { // Column cn has no index. 2316 return nil, []string{fmt.Sprintf("%s(%s)", t.name, cn)}, nil 2317 } 2318 2319 kind := indexFalse 2320 if trueValue { 2321 kind = indexTrue 2322 } 2323 return &indexPlan{t, cn, ix.name, ix.x, kind, nil, nil}, nil, nil 2324 } 2325 return nil, nil, nil 2326 } 2327 2328 func (r *tableDefaultPlan) filterIsNull(x *isNull) (plan, []string, error) { 2329 ok, cn := isColumnExpression(x.expr) 2330 if !ok { 2331 return nil, nil, nil 2332 } 2333 2334 t := r.t 2335 _, ix := t.findIndexByColName(cn) 2336 if ix == nil { // Column cn has no index. 2337 return nil, []string{fmt.Sprintf("%s(%s)", t.name, cn)}, nil 2338 } 2339 2340 switch { 2341 case x.not: 2342 return &indexPlan{t, cn, ix.name, ix.x, indexIsNotNull, nil, nil}, nil, nil 2343 default: 2344 return &indexPlan{t, cn, ix.name, ix.x, indexIsNull, nil, nil}, nil, nil 2345 } 2346 } 2347 2348 func (r *tableDefaultPlan) filter(expr expression) (plan, []string, error) { 2349 cols := mentionedColumns(expr) 2350 for _, v := range r.fields { 2351 delete(cols, v) 2352 } 2353 for k := range cols { 2354 return nil, nil, fmt.Errorf("unknown field %s", k) 2355 } 2356 2357 var is []string 2358 2359 //TODO var sexpr string 2360 //TODO for _, ix := range t.indices2 { 2361 //TODO if len(ix.exprList) != 1 { 2362 //TODO continue 2363 //TODO } 2364 2365 //TODO if sexpr == "" { 2366 //TODO sexpr = expr.String() 2367 //TODO } 2368 //TODO if ix.sources[0] != sexpr { 2369 //TODO continue 2370 //TODO } 2371 2372 //TODO } 2373 2374 switch x := expr.(type) { 2375 case *binaryOperation: 2376 return r.filterBinOp(x) 2377 case *ident: 2378 return r.filterIdent(x, true) 2379 case *isNull: 2380 return r.filterIsNull(x) 2381 case *unaryOperation: 2382 if x.op != '!' { 2383 break 2384 } 2385 2386 if operand, ok := x.v.(*ident); ok { 2387 return r.filterIdent(operand, false) 2388 } 2389 default: 2390 //dbg("", expr) 2391 return nil, is, nil //TODO 2392 } 2393 2394 return nil, is, nil 2395 } 2396 2397 func (r *tableDefaultPlan) do(ctx *execCtx, f func(interface{}, []interface{}) (bool, error)) (err error) { 2398 t := r.t 2399 cols := t.cols 2400 h := t.head 2401 for h > 0 { 2402 rec, err := t.row0(ctx, h) 2403 if err != nil { 2404 return err 2405 } 2406 2407 h = rec[0].(int64) 2408 id := rec[1].(int64) 2409 for i, c := range cols { 2410 rec[i] = rec[c.index+2] 2411 } 2412 if m, err := f(id, rec[:len(cols)]); !m || err != nil { 2413 return err 2414 } 2415 } 2416 return nil 2417 } 2418 2419 func (r *tableDefaultPlan) fieldNames() []string { return r.fields } 2420 2421 type nullPlan struct { 2422 fields []string 2423 } 2424 2425 func (r *nullPlan) hasID() bool { return false } 2426 2427 func (r *nullPlan) fieldNames() []string { return r.fields } 2428 2429 func (r *nullPlan) explain(w strutil.Formatter) { 2430 w.Format("┌Iterate no rows\n└Output field names %v\n", qnames(r.fields)) 2431 } 2432 2433 func (r *nullPlan) do(*execCtx, func(interface{}, []interface{}) (bool, error)) error { 2434 return nil 2435 } 2436 2437 func (r *nullPlan) filter(expr expression) (plan, []string, error) { 2438 return r, nil, nil 2439 } 2440 2441 type leftJoinDefaultPlan struct { 2442 on expression 2443 rsets []plan 2444 names []string 2445 right int 2446 fields []string 2447 } 2448 2449 func (r *leftJoinDefaultPlan) hasID() bool { return false } 2450 2451 func (r *leftJoinDefaultPlan) explain(w strutil.Formatter) { 2452 w.Format("┌Compute Cartesian product of%i\n") 2453 for i, v := range r.rsets { 2454 sel := !isTableOrIndex(v) 2455 if sel { 2456 w.Format("┌Iterate all rows of virtual table %q%i\n", r.names[i]) 2457 } 2458 v.explain(w) 2459 if sel { 2460 w.Format("%u└Output field names %v\n", qnames(v.fieldNames())) 2461 } 2462 } 2463 w.Format("Extend the product with all NULL rows of %q when no match for %v%u\n", r.names[len(r.names)-1], r.on) 2464 w.Format("└Output field names %v\n", qnames(r.fields)) 2465 } 2466 2467 func (r *leftJoinDefaultPlan) filter(expr expression) (plan, []string, error) { 2468 var is []string 2469 for i, v := range r.names { 2470 e2, err := expr.clone(nil, v) 2471 if err != nil { 2472 return nil, nil, err 2473 } 2474 2475 p2, is2, err := r.rsets[i].filter(e2) 2476 is = append(is, is2...) 2477 if err != nil { 2478 return nil, nil, err 2479 } 2480 2481 if p2 != nil { 2482 r.rsets[i] = p2 2483 return r, is, nil 2484 } 2485 } 2486 return nil, is, nil 2487 } 2488 2489 type rightJoinDefaultPlan struct { 2490 leftJoinDefaultPlan 2491 } 2492 2493 func (r *rightJoinDefaultPlan) hasID() bool { return false } 2494 2495 func (r *rightJoinDefaultPlan) explain(w strutil.Formatter) { 2496 w.Format("┌Compute Cartesian product of%i\n") 2497 for i, v := range r.rsets { 2498 sel := !isTableOrIndex(v) 2499 if sel { 2500 w.Format("┌Iterate all rows of virtual table %q%i\n", r.names[i]) 2501 } 2502 v.explain(w) 2503 if sel { 2504 w.Format("%u└Output field names %v\n", qnames(v.fieldNames())) 2505 } 2506 } 2507 w.Format("Extend the product with all NULL rows of all but %q when no match for %v%u\n", r.names[len(r.names)-1], r.on) 2508 w.Format("└Output field names %v\n", qnames(r.fields)) 2509 } 2510 2511 func (r *rightJoinDefaultPlan) filter(expr expression) (plan, []string, error) { 2512 var is []string 2513 for i, v := range r.names { 2514 e2, err := expr.clone(nil, v) 2515 if err != nil { 2516 return nil, nil, err 2517 } 2518 2519 p2, is2, err := r.rsets[i].filter(e2) 2520 is = append(is, is2...) 2521 if err != nil { 2522 return nil, nil, err 2523 } 2524 2525 if p2 != nil { 2526 r.rsets[i] = p2 2527 return r, is, nil 2528 } 2529 } 2530 return nil, is, nil 2531 } 2532 2533 type fullJoinDefaultPlan struct { 2534 leftJoinDefaultPlan 2535 } 2536 2537 func (r *fullJoinDefaultPlan) hasID() bool { return false } 2538 2539 func (r *fullJoinDefaultPlan) explain(w strutil.Formatter) { 2540 w.Format("┌Compute Cartesian product of%i\n") 2541 for i, v := range r.rsets { 2542 sel := !isTableOrIndex(v) 2543 if sel { 2544 w.Format("┌Iterate all rows of virtual table %q%i\n", r.names[i]) 2545 } 2546 v.explain(w) 2547 if sel { 2548 w.Format("%u└Output field names %v\n", qnames(v.fieldNames())) 2549 } 2550 } 2551 w.Format("Extend the product with all NULL rows of %q when no match for %v\n", r.names[len(r.names)-1], r.on) 2552 w.Format("Extend the product with all NULL rows of all but %q when no match for %v%u\n", r.names[len(r.names)-1], r.on) 2553 w.Format("└Output field names %v\n", qnames(r.fields)) 2554 } 2555 2556 func (r *fullJoinDefaultPlan) filter(expr expression) (plan, []string, error) { 2557 var is []string 2558 for i, v := range r.names { 2559 e2, err := expr.clone(nil, v) 2560 if err != nil { 2561 return nil, nil, err 2562 } 2563 2564 p2, is2, err := r.rsets[i].filter(e2) 2565 is = append(is, is2...) 2566 if err != nil { 2567 return nil, nil, err 2568 } 2569 2570 if p2 != nil { 2571 r.rsets[i] = p2 2572 return r, is, nil 2573 } 2574 } 2575 return nil, is, nil 2576 } 2577 2578 func (r *leftJoinDefaultPlan) fieldNames() []string { return r.fields } 2579 2580 func (r *leftJoinDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (more bool, err error)) error { 2581 m := map[interface{}]interface{}{} 2582 ids := map[string]interface{}{} 2583 var g func([]interface{}, []plan, int) error 2584 var match bool 2585 g = func(prefix []interface{}, rsets []plan, x int) (err error) { 2586 return rsets[0].do(ctx, func(id interface{}, in []interface{}) (bool, error) { 2587 ids[r.names[x]] = id 2588 row := append(prefix, in...) 2589 if len(rsets) > 1 { 2590 if len(rsets) == 2 { 2591 match = false 2592 } 2593 if err = g(row, rsets[1:], x+1); err != nil { 2594 return false, err 2595 } 2596 2597 if len(rsets) != 2 || match { 2598 return true, nil 2599 } 2600 2601 ids[r.names[x+1]] = nil 2602 return f(ids, append(row, make([]interface{}, r.right)...)) 2603 } 2604 2605 for i, fld := range r.fields { 2606 if fld != "" { 2607 m[fld] = row[i] 2608 } 2609 } 2610 2611 val, err := r.on.eval(ctx, m) 2612 if err != nil { 2613 return false, err 2614 } 2615 2616 if val == nil { 2617 return true, nil 2618 } 2619 2620 x, ok := val.(bool) 2621 if !ok { 2622 return false, fmt.Errorf("invalid ON expression %s (value of type %T)", val, val) 2623 } 2624 2625 if !x { 2626 return true, nil 2627 } 2628 2629 match = true 2630 return f(ids, row) 2631 }) 2632 } 2633 return g(nil, r.rsets, 0) 2634 } 2635 2636 func (r *rightJoinDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (more bool, err error)) error { 2637 right := r.right 2638 left := len(r.fields) - right 2639 n := len(r.rsets) 2640 m := map[interface{}]interface{}{} 2641 ids := map[string]interface{}{} 2642 var g func([]interface{}, []plan, int) error 2643 var match bool 2644 nf := len(r.fields) 2645 fields := append(append([]string(nil), r.fields[nf-right:]...), r.fields[:nf-right]...) 2646 g = func(prefix []interface{}, rsets []plan, x int) (err error) { 2647 return rsets[0].do(ctx, func(id interface{}, in []interface{}) (bool, error) { 2648 ids[r.names[x]] = id 2649 row := append(prefix, in...) 2650 if len(rsets) > 1 { 2651 if len(rsets) == n { 2652 match = false 2653 } 2654 if err = g(row, rsets[1:], x+1); err != nil { 2655 return false, err 2656 } 2657 2658 if len(rsets) != n || match { 2659 return true, nil 2660 } 2661 2662 for i := 0; i < n-1; i++ { 2663 ids[r.names[i]] = nil 2664 } 2665 2666 // rigth, left -> left, right 2667 return f(ids, append(make([]interface{}, left), row[:right]...)) 2668 } 2669 2670 for i, fld := range fields { 2671 if fld != "" { 2672 m[fld] = row[i] 2673 } 2674 } 2675 2676 val, err := r.on.eval(ctx, m) 2677 if err != nil { 2678 return false, err 2679 } 2680 2681 if val == nil { 2682 return true, nil 2683 } 2684 2685 x, ok := val.(bool) 2686 if !ok { 2687 return false, fmt.Errorf("invalid ON expression %s (value of type %T)", val, val) 2688 } 2689 2690 if !x { 2691 return true, nil 2692 } 2693 2694 match = true 2695 // rigth, left -> left, right 2696 return f(ids, append(append([]interface{}(nil), row[right:]...), row[:right]...)) 2697 }) 2698 } 2699 return g(nil, append([]plan{r.rsets[n-1]}, r.rsets[:n-1]...), 0) 2700 } 2701 2702 func (r *fullJoinDefaultPlan) do(ctx *execCtx, f func(id interface{}, data []interface{}) (more bool, err error)) error { 2703 b3 := b.TreeNew(func(a, b interface{}) int { 2704 x := a.(int64) 2705 y := b.(int64) 2706 if x < y { 2707 return -1 2708 } 2709 2710 if x == y { 2711 return 0 2712 } 2713 2714 return 1 2715 }) 2716 m := map[interface{}]interface{}{} 2717 ids := map[string]interface{}{} 2718 var g func([]interface{}, []plan, int) error 2719 var match bool 2720 var rid int64 2721 firstR := true 2722 g = func(prefix []interface{}, rsets []plan, x int) (err error) { 2723 return rsets[0].do(ctx, func(id interface{}, in []interface{}) (bool, error) { 2724 ids[r.names[x]] = id 2725 row := append(prefix, in...) 2726 if len(rsets) > 1 { 2727 if len(rsets) == 2 { 2728 match = false 2729 rid = 0 2730 } 2731 if err = g(row, rsets[1:], x+1); err != nil { 2732 return false, err 2733 } 2734 2735 if len(rsets) == 2 { 2736 firstR = false 2737 } 2738 if len(rsets) != 2 || match { 2739 return true, nil 2740 } 2741 2742 ids[r.names[x+1]] = nil 2743 return f(ids, append(row, make([]interface{}, r.right)...)) 2744 } 2745 2746 rid++ 2747 if firstR { 2748 b3.Set(rid, in) 2749 } 2750 for i, fld := range r.fields { 2751 if fld != "" { 2752 m[fld] = row[i] 2753 } 2754 } 2755 2756 val, err := r.on.eval(ctx, m) 2757 if err != nil { 2758 return false, err 2759 } 2760 2761 if val == nil { 2762 return true, nil 2763 } 2764 2765 x, ok := val.(bool) 2766 if !ok { 2767 return false, fmt.Errorf("invalid ON expression %s (value of type %T)", val, val) 2768 } 2769 2770 if !x { 2771 return true, nil 2772 } 2773 2774 match = true 2775 b3.Delete(rid) 2776 return f(ids, row) 2777 }) 2778 } 2779 if err := g(nil, r.rsets, 0); err != nil { 2780 return err 2781 } 2782 2783 it, err := b3.SeekFirst() 2784 if err != nil { 2785 return noEOF(err) 2786 } 2787 2788 pref := make([]interface{}, len(r.fields)-r.right) 2789 for { 2790 _, v, err := it.Next() 2791 if err != nil { 2792 return noEOF(err) 2793 } 2794 2795 more, err := f(nil, append(pref, v.([]interface{})...)) 2796 if err != nil || !more { 2797 return err 2798 } 2799 } 2800 }