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