go-hep.org/x/hep@v0.38.1/groot/rsql/rsqldrv/expr.go (about) 1 // Copyright ©2019 The go-hep 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 rsqldrv // import "go-hep.org/x/hep/groot/rsql/rsqldrv" 6 7 import ( 8 "database/sql/driver" 9 "fmt" 10 "reflect" 11 "strconv" 12 "strings" 13 14 "github.com/xwb1989/sqlparser" 15 ) 16 17 type expression interface { 18 sql() sqlparser.Expr 19 20 eval(ectx *execCtx, vctx map[any]any) (v any, err error) 21 isStatic() bool 22 } 23 24 type execCtx struct { 25 db *driverConn 26 } 27 28 func newExecCtx(db *driverConn, args []driver.NamedValue) *execCtx { 29 ectx := execCtx{db: db} 30 return &ectx 31 } 32 33 type binExpr struct { 34 expr sqlparser.Expr 35 36 op operator 37 l expression 38 r expression 39 } 40 41 func newBinExpr(expr sqlparser.Expr, op operator, x, y expression) (v expression, err error) { 42 be := &binExpr{ 43 expr: expr, 44 op: op, 45 l: x, 46 r: y, 47 } 48 49 return be, nil 50 } 51 52 func (expr *binExpr) sql() sqlparser.Expr { return expr.expr } 53 func (expr *binExpr) eval(ectx *execCtx, vctx map[any]any) (r any, err error) { 54 defer func() { 55 if e := recover(); e != nil { 56 switch x := e.(type) { 57 case error: 58 r, err = nil, x 59 default: 60 r, err = nil, fmt.Errorf("%v", x) 61 } 62 } 63 }() 64 65 switch expr.op { 66 case opAndAnd: 67 l, err := expr.l.eval(ectx, vctx) 68 if err != nil { 69 return nil, err 70 } 71 72 switch l := l.(type) { 73 case bool: 74 if !l { 75 return false, nil 76 } 77 78 r, err := expr.r.eval(ectx, vctx) 79 if err != nil { 80 return nil, err 81 } 82 83 switch r := r.(type) { 84 case bool: 85 return r, nil 86 default: 87 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 88 } 89 90 default: 91 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 92 } 93 94 case opOrOr: 95 l, err := expr.l.eval(ectx, vctx) 96 if err != nil { 97 return nil, err 98 } 99 100 switch l := l.(type) { 101 case bool: 102 if l { 103 return true, nil 104 } 105 106 r, err := expr.r.eval(ectx, vctx) 107 if err != nil { 108 return nil, err 109 } 110 111 switch r := r.(type) { 112 case bool: 113 return r, nil 114 default: 115 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 116 } 117 118 default: 119 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 120 } 121 122 case opLT: 123 l, r := expr.load(ectx, vctx) 124 switch l := l.(type) { 125 case idealUint: 126 switch r := r.(type) { 127 case idealUint: 128 return l < r, nil 129 default: 130 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 131 } 132 case idealInt: 133 switch r := r.(type) { 134 case idealInt: 135 return l < r, nil 136 default: 137 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 138 } 139 case idealFloat: 140 switch r := r.(type) { 141 case idealFloat: 142 return l < r, nil 143 default: 144 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 145 } 146 case int8: 147 switch r := r.(type) { 148 case int8: 149 return l < r, nil 150 default: 151 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 152 } 153 case int16: 154 switch r := r.(type) { 155 case int16: 156 return l < r, nil 157 default: 158 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 159 } 160 case int32: 161 switch r := r.(type) { 162 case int32: 163 return l < r, nil 164 default: 165 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 166 } 167 case int64: 168 switch r := r.(type) { 169 case int64: 170 return l < r, nil 171 default: 172 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 173 } 174 case uint8: 175 switch r := r.(type) { 176 case uint8: 177 return l < r, nil 178 default: 179 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 180 } 181 case uint16: 182 switch r := r.(type) { 183 case uint16: 184 return l < r, nil 185 default: 186 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 187 } 188 case uint32: 189 switch r := r.(type) { 190 case uint32: 191 return l < r, nil 192 default: 193 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 194 } 195 case uint64: 196 switch r := r.(type) { 197 case uint64: 198 return l < r, nil 199 default: 200 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 201 } 202 case float32: 203 switch r := r.(type) { 204 case float32: 205 return l < r, nil 206 default: 207 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 208 } 209 case float64: 210 switch r := r.(type) { 211 case float64: 212 return l < r, nil 213 default: 214 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 215 } 216 case string: 217 switch r := r.(type) { 218 case string: 219 return l < r, nil 220 default: 221 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 222 } 223 default: 224 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 225 } 226 227 case opLE: 228 l, r := expr.load(ectx, vctx) 229 switch l := l.(type) { 230 case idealUint: 231 switch r := r.(type) { 232 case idealUint: 233 return l <= r, nil 234 default: 235 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 236 } 237 case idealInt: 238 switch r := r.(type) { 239 case idealInt: 240 return l <= r, nil 241 default: 242 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 243 } 244 case idealFloat: 245 switch r := r.(type) { 246 case idealFloat: 247 return l <= r, nil 248 default: 249 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 250 } 251 case int8: 252 switch r := r.(type) { 253 case int8: 254 return l <= r, nil 255 default: 256 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 257 } 258 case int16: 259 switch r := r.(type) { 260 case int16: 261 return l <= r, nil 262 default: 263 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 264 } 265 case int32: 266 switch r := r.(type) { 267 case int32: 268 return l <= r, nil 269 default: 270 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 271 } 272 case int64: 273 switch r := r.(type) { 274 case int64: 275 return l <= r, nil 276 default: 277 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 278 } 279 case uint8: 280 switch r := r.(type) { 281 case uint8: 282 return l <= r, nil 283 default: 284 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 285 } 286 case uint16: 287 switch r := r.(type) { 288 case uint16: 289 return l <= r, nil 290 default: 291 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 292 } 293 case uint32: 294 switch r := r.(type) { 295 case uint32: 296 return l <= r, nil 297 default: 298 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 299 } 300 case uint64: 301 switch r := r.(type) { 302 case uint64: 303 return l <= r, nil 304 default: 305 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 306 } 307 case float32: 308 switch r := r.(type) { 309 case float32: 310 return l <= r, nil 311 default: 312 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 313 } 314 case float64: 315 switch r := r.(type) { 316 case float64: 317 return l <= r, nil 318 default: 319 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 320 } 321 case string: 322 switch r := r.(type) { 323 case string: 324 return l <= r, nil 325 default: 326 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 327 } 328 default: 329 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 330 } 331 332 case opGT: 333 l, r := expr.load(ectx, vctx) 334 switch l := l.(type) { 335 case idealUint: 336 switch r := r.(type) { 337 case idealUint: 338 return l > r, nil 339 default: 340 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 341 } 342 case idealInt: 343 switch r := r.(type) { 344 case idealInt: 345 return l > r, nil 346 default: 347 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 348 } 349 case idealFloat: 350 switch r := r.(type) { 351 case idealFloat: 352 return l > r, nil 353 default: 354 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 355 } 356 case int8: 357 switch r := r.(type) { 358 case int8: 359 return l > r, nil 360 default: 361 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 362 } 363 case int16: 364 switch r := r.(type) { 365 case int16: 366 return l > r, nil 367 default: 368 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 369 } 370 case int32: 371 switch r := r.(type) { 372 case int32: 373 return l > r, nil 374 default: 375 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 376 } 377 case int64: 378 switch r := r.(type) { 379 case int64: 380 return l > r, nil 381 default: 382 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 383 } 384 case uint8: 385 switch r := r.(type) { 386 case uint8: 387 return l > r, nil 388 default: 389 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 390 } 391 case uint16: 392 switch r := r.(type) { 393 case uint16: 394 return l > r, nil 395 default: 396 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 397 } 398 case uint32: 399 switch r := r.(type) { 400 case uint32: 401 return l > r, nil 402 default: 403 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 404 } 405 case uint64: 406 switch r := r.(type) { 407 case uint64: 408 return l > r, nil 409 default: 410 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 411 } 412 case float32: 413 switch r := r.(type) { 414 case float32: 415 return l > r, nil 416 default: 417 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 418 } 419 case float64: 420 switch r := r.(type) { 421 case float64: 422 return l > r, nil 423 default: 424 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 425 } 426 case string: 427 switch r := r.(type) { 428 case string: 429 return l > r, nil 430 default: 431 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 432 } 433 default: 434 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %#v: %#v", expr.l, l)) 435 } 436 437 case opGE: 438 l, r := expr.load(ectx, vctx) 439 switch l := l.(type) { 440 case idealUint: 441 switch r := r.(type) { 442 case idealUint: 443 return l >= r, nil 444 default: 445 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 446 } 447 case idealInt: 448 switch r := r.(type) { 449 case idealInt: 450 return l >= r, nil 451 default: 452 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 453 } 454 case idealFloat: 455 switch r := r.(type) { 456 case idealFloat: 457 return l >= r, nil 458 default: 459 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 460 } 461 case int8: 462 switch r := r.(type) { 463 case int8: 464 return l >= r, nil 465 default: 466 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 467 } 468 case int16: 469 switch r := r.(type) { 470 case int16: 471 return l >= r, nil 472 default: 473 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 474 } 475 case int32: 476 switch r := r.(type) { 477 case int32: 478 return l >= r, nil 479 default: 480 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 481 } 482 case int64: 483 switch r := r.(type) { 484 case int64: 485 return l >= r, nil 486 default: 487 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 488 } 489 case uint8: 490 switch r := r.(type) { 491 case uint8: 492 return l >= r, nil 493 default: 494 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 495 } 496 case uint16: 497 switch r := r.(type) { 498 case uint16: 499 return l >= r, nil 500 default: 501 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 502 } 503 case uint32: 504 switch r := r.(type) { 505 case uint32: 506 return l >= r, nil 507 default: 508 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 509 } 510 case uint64: 511 switch r := r.(type) { 512 case uint64: 513 return l >= r, nil 514 default: 515 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 516 } 517 case float32: 518 switch r := r.(type) { 519 case float32: 520 return l >= r, nil 521 default: 522 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 523 } 524 case float64: 525 switch r := r.(type) { 526 case float64: 527 return l >= r, nil 528 default: 529 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 530 } 531 case string: 532 switch r := r.(type) { 533 case string: 534 return l >= r, nil 535 default: 536 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 537 } 538 default: 539 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 540 } 541 542 case opNotEq: 543 l, r := expr.load(ectx, vctx) 544 switch l := l.(type) { 545 case idealUint: 546 switch r := r.(type) { 547 case idealUint: 548 return l != r, nil 549 default: 550 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 551 } 552 case idealInt: 553 switch r := r.(type) { 554 case idealInt: 555 return l != r, nil 556 default: 557 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 558 } 559 case idealFloat: 560 switch r := r.(type) { 561 case idealFloat: 562 return l != r, nil 563 default: 564 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 565 } 566 case bool: 567 switch r := r.(type) { 568 case bool: 569 return l != r, nil 570 default: 571 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 572 } 573 case int8: 574 switch r := r.(type) { 575 case int8: 576 return l != r, nil 577 default: 578 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 579 } 580 case int16: 581 switch r := r.(type) { 582 case int16: 583 return l != r, nil 584 default: 585 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 586 } 587 case int32: 588 switch r := r.(type) { 589 case int32: 590 return l != r, nil 591 default: 592 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 593 } 594 case int64: 595 switch r := r.(type) { 596 case int64: 597 return l != r, nil 598 default: 599 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 600 } 601 case uint8: 602 switch r := r.(type) { 603 case uint8: 604 return l != r, nil 605 default: 606 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 607 } 608 case uint16: 609 switch r := r.(type) { 610 case uint16: 611 return l != r, nil 612 default: 613 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 614 } 615 case uint32: 616 switch r := r.(type) { 617 case uint32: 618 return l != r, nil 619 default: 620 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 621 } 622 case uint64: 623 switch r := r.(type) { 624 case uint64: 625 return l != r, nil 626 default: 627 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 628 } 629 case float32: 630 switch r := r.(type) { 631 case float32: 632 return l != r, nil 633 default: 634 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 635 } 636 case float64: 637 switch r := r.(type) { 638 case float64: 639 return l != r, nil 640 default: 641 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 642 } 643 case string: 644 switch r := r.(type) { 645 case string: 646 return l != r, nil 647 default: 648 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 649 } 650 default: 651 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 652 } 653 654 case opEq: 655 l, r := expr.load(ectx, vctx) 656 switch l := l.(type) { 657 case idealUint: 658 switch r := r.(type) { 659 case idealUint: 660 return l == r, nil 661 default: 662 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 663 } 664 case idealInt: 665 switch r := r.(type) { 666 case idealInt: 667 return l == r, nil 668 default: 669 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 670 } 671 case idealFloat: 672 switch r := r.(type) { 673 case idealFloat: 674 return l == r, nil 675 default: 676 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 677 } 678 case bool: 679 switch r := r.(type) { 680 case bool: 681 return l == r, nil 682 default: 683 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 684 } 685 case int8: 686 switch r := r.(type) { 687 case int8: 688 return l == r, nil 689 default: 690 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 691 } 692 case int16: 693 switch r := r.(type) { 694 case int16: 695 return l == r, nil 696 default: 697 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 698 } 699 case int32: 700 switch r := r.(type) { 701 case int32: 702 return l == r, nil 703 default: 704 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 705 } 706 case int64: 707 switch r := r.(type) { 708 case int64: 709 return l == r, nil 710 default: 711 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 712 } 713 case uint8: 714 switch r := r.(type) { 715 case uint8: 716 return l == r, nil 717 default: 718 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 719 } 720 case uint16: 721 switch r := r.(type) { 722 case uint16: 723 return l == r, nil 724 default: 725 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 726 } 727 case uint32: 728 switch r := r.(type) { 729 case uint32: 730 return l == r, nil 731 default: 732 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 733 } 734 case uint64: 735 switch r := r.(type) { 736 case uint64: 737 return l == r, nil 738 default: 739 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 740 } 741 case float32: 742 switch r := r.(type) { 743 case float32: 744 return l == r, nil 745 default: 746 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 747 } 748 case float64: 749 switch r := r.(type) { 750 case float64: 751 return l == r, nil 752 default: 753 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 754 } 755 case string: 756 switch r := r.(type) { 757 case string: 758 return l == r, nil 759 default: 760 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 761 } 762 default: 763 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 764 } 765 766 case opAdd: 767 l, r := expr.load(ectx, vctx) 768 switch l := l.(type) { 769 case idealUint: 770 switch r := r.(type) { 771 case idealUint: 772 return idealUint(uint64(l) + uint64(r)), nil 773 default: 774 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 775 } 776 case idealInt: 777 switch r := r.(type) { 778 case idealInt: 779 return idealInt(int64(l) + int64(r)), nil 780 default: 781 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 782 } 783 case idealFloat: 784 switch r := r.(type) { 785 case idealFloat: 786 return idealFloat(float64(l) + float64(r)), nil 787 default: 788 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 789 } 790 case int8: 791 switch r := r.(type) { 792 case int8: 793 return l + r, nil 794 default: 795 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 796 } 797 case int16: 798 switch r := r.(type) { 799 case int16: 800 return l + r, nil 801 default: 802 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 803 } 804 case int32: 805 switch r := r.(type) { 806 case int32: 807 return l + r, nil 808 default: 809 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 810 } 811 case int64: 812 switch r := r.(type) { 813 case int64: 814 return l + r, nil 815 default: 816 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 817 } 818 case uint8: 819 switch r := r.(type) { 820 case uint8: 821 return l + r, nil 822 default: 823 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 824 } 825 case uint16: 826 switch r := r.(type) { 827 case uint16: 828 return l + r, nil 829 default: 830 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 831 } 832 case uint32: 833 switch r := r.(type) { 834 case uint32: 835 return l + r, nil 836 default: 837 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 838 } 839 case uint64: 840 switch r := r.(type) { 841 case uint64: 842 return l + r, nil 843 default: 844 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 845 } 846 case float32: 847 switch r := r.(type) { 848 case float32: 849 return l + r, nil 850 default: 851 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 852 } 853 case float64: 854 switch r := r.(type) { 855 case float64: 856 return l + r, nil 857 default: 858 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 859 } 860 case string: 861 switch r := r.(type) { 862 case string: 863 return l + r, nil 864 default: 865 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 866 } 867 default: 868 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 869 } 870 871 case opSub: 872 l, r := expr.load(ectx, vctx) 873 switch l := l.(type) { 874 case idealUint: 875 switch r := r.(type) { 876 case idealUint: 877 return idealUint(uint64(l) - uint64(r)), nil 878 default: 879 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 880 } 881 case idealInt: 882 switch r := r.(type) { 883 case idealInt: 884 return idealInt(int64(l) - int64(r)), nil 885 default: 886 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 887 } 888 case idealFloat: 889 switch r := r.(type) { 890 case idealFloat: 891 return idealFloat(float64(l) - float64(r)), nil 892 default: 893 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 894 } 895 case int8: 896 switch r := r.(type) { 897 case int8: 898 return l - r, nil 899 default: 900 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 901 } 902 case int16: 903 switch r := r.(type) { 904 case int16: 905 return l - r, nil 906 default: 907 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 908 } 909 case int32: 910 switch r := r.(type) { 911 case int32: 912 return l - r, nil 913 default: 914 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 915 } 916 case int64: 917 switch r := r.(type) { 918 case int64: 919 return l - r, nil 920 default: 921 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 922 } 923 case uint8: 924 switch r := r.(type) { 925 case uint8: 926 return l - r, nil 927 default: 928 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 929 } 930 case uint16: 931 switch r := r.(type) { 932 case uint16: 933 return l - r, nil 934 default: 935 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 936 } 937 case uint32: 938 switch r := r.(type) { 939 case uint32: 940 return l - r, nil 941 default: 942 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 943 } 944 case uint64: 945 switch r := r.(type) { 946 case uint64: 947 return l - r, nil 948 default: 949 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 950 } 951 case float32: 952 switch r := r.(type) { 953 case float32: 954 return l - r, nil 955 default: 956 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 957 } 958 case float64: 959 switch r := r.(type) { 960 case float64: 961 return l - r, nil 962 default: 963 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 964 } 965 default: 966 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 967 } 968 969 case opMul: 970 l, r := expr.load(ectx, vctx) 971 switch l := l.(type) { 972 case idealUint: 973 switch r := r.(type) { 974 case idealUint: 975 return idealUint(uint64(l) * uint64(r)), nil 976 default: 977 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 978 } 979 case idealInt: 980 switch r := r.(type) { 981 case idealInt: 982 return idealInt(int64(l) * int64(r)), nil 983 default: 984 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 985 } 986 case idealFloat: 987 switch r := r.(type) { 988 case idealFloat: 989 return idealFloat(float64(l) * float64(r)), nil 990 default: 991 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 992 } 993 case int8: 994 switch r := r.(type) { 995 case int8: 996 return l * r, nil 997 default: 998 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 999 } 1000 case int16: 1001 switch r := r.(type) { 1002 case int16: 1003 return l * r, nil 1004 default: 1005 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1006 } 1007 case int32: 1008 switch r := r.(type) { 1009 case int32: 1010 return l * r, nil 1011 default: 1012 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1013 } 1014 case int64: 1015 switch r := r.(type) { 1016 case int64: 1017 return l * r, nil 1018 default: 1019 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1020 } 1021 case uint8: 1022 switch r := r.(type) { 1023 case uint8: 1024 return l * r, nil 1025 default: 1026 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1027 } 1028 case uint16: 1029 switch r := r.(type) { 1030 case uint16: 1031 return l * r, nil 1032 default: 1033 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1034 } 1035 case uint32: 1036 switch r := r.(type) { 1037 case uint32: 1038 return l * r, nil 1039 default: 1040 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1041 } 1042 case uint64: 1043 switch r := r.(type) { 1044 case uint64: 1045 return l * r, nil 1046 default: 1047 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1048 } 1049 case float32: 1050 switch r := r.(type) { 1051 case float32: 1052 return l * r, nil 1053 default: 1054 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1055 } 1056 case float64: 1057 switch r := r.(type) { 1058 case float64: 1059 return l * r, nil 1060 default: 1061 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1062 } 1063 default: 1064 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 1065 } 1066 1067 case opDiv: 1068 l, r := expr.load(ectx, vctx) 1069 switch l := l.(type) { 1070 case idealUint: 1071 switch r := r.(type) { 1072 case idealUint: 1073 return idealUint(uint64(l) / uint64(r)), nil 1074 default: 1075 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 1076 } 1077 case idealInt: 1078 switch r := r.(type) { 1079 case idealInt: 1080 return idealInt(int64(l) / int64(r)), nil 1081 default: 1082 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 1083 } 1084 case idealFloat: 1085 switch r := r.(type) { 1086 case idealFloat: 1087 return idealFloat(float64(l) / float64(r)), nil 1088 default: 1089 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v %T", expr.r, r, r)) 1090 } 1091 case int8: 1092 switch r := r.(type) { 1093 case int8: 1094 return l / r, nil 1095 default: 1096 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1097 } 1098 case int16: 1099 switch r := r.(type) { 1100 case int16: 1101 return l / r, nil 1102 default: 1103 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1104 } 1105 case int32: 1106 switch r := r.(type) { 1107 case int32: 1108 return l / r, nil 1109 default: 1110 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1111 } 1112 case int64: 1113 switch r := r.(type) { 1114 case int64: 1115 return l / r, nil 1116 default: 1117 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1118 } 1119 case uint8: 1120 switch r := r.(type) { 1121 case uint8: 1122 return l / r, nil 1123 default: 1124 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1125 } 1126 case uint16: 1127 switch r := r.(type) { 1128 case uint16: 1129 return l / r, nil 1130 default: 1131 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1132 } 1133 case uint32: 1134 switch r := r.(type) { 1135 case uint32: 1136 return l / r, nil 1137 default: 1138 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1139 } 1140 case uint64: 1141 switch r := r.(type) { 1142 case uint64: 1143 return l / r, nil 1144 default: 1145 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1146 } 1147 case float32: 1148 switch r := r.(type) { 1149 case float32: 1150 return l / r, nil 1151 default: 1152 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1153 } 1154 case float64: 1155 switch r := r.(type) { 1156 case float64: 1157 return l / r, nil 1158 default: 1159 panic(fmt.Errorf("sqldrv: invalid right-operand value/type in %v: %#v", expr.r, r)) 1160 } 1161 default: 1162 panic(fmt.Errorf("sqldrv: invalid left-operand value/type in %v: %#v", expr.l, l)) 1163 } 1164 1165 } 1166 1167 panic("impossible") 1168 } 1169 1170 func (expr *binExpr) isStatic() bool { 1171 return expr.l.isStatic() && expr.r.isStatic() 1172 } 1173 1174 func (expr *binExpr) load(ectx *execCtx, vctx map[any]any) (l, r any) { 1175 l, r = eval2(expr.l, expr.r, ectx, vctx) 1176 return coerce(l, r) 1177 } 1178 1179 func eval(v expression, ectx *execCtx, vctx map[any]any) (y any) { 1180 y, err := v.eval(ectx, vctx) 1181 if err != nil { 1182 panic(err) // panic ok here 1183 } 1184 return 1185 } 1186 1187 func eval2(a, b expression, ectx *execCtx, vctx map[any]any) (x, y any) { 1188 return eval(a, ectx, vctx), eval(b, ectx, vctx) 1189 } 1190 1191 type operator byte 1192 1193 const ( 1194 opInvalid operator = iota 1195 opAnd 1196 opOr 1197 opXor 1198 opAdd 1199 opSub 1200 opMul 1201 opDiv 1202 opAndAnd 1203 opOrOr 1204 opLT 1205 opGT 1206 opLE 1207 opGE 1208 opEq 1209 opNotEq 1210 opRShift 1211 opLShift 1212 ) 1213 1214 func operatorFrom(opstr string) operator { 1215 switch opstr { 1216 case sqlparser.LessThanStr: 1217 return opLT 1218 case sqlparser.LessEqualStr: 1219 return opLE 1220 case sqlparser.GreaterThanStr: 1221 return opGT 1222 case sqlparser.GreaterEqualStr: 1223 return opGE 1224 case sqlparser.NotEqualStr: 1225 return opNotEq 1226 case sqlparser.EqualStr: 1227 return opEq 1228 case sqlparser.BitAndStr: 1229 return opAnd 1230 case sqlparser.BitXorStr: 1231 return opXor 1232 case sqlparser.BitOrStr: 1233 return opOr 1234 1235 case sqlparser.PlusStr: 1236 return opAdd 1237 case sqlparser.MinusStr: 1238 return opSub 1239 case sqlparser.MultStr: 1240 return opMul 1241 case sqlparser.DivStr: 1242 return opDiv 1243 1244 case sqlparser.ShiftLeftStr: 1245 return opLShift 1246 case sqlparser.ShiftRightStr: 1247 return opRShift 1248 } 1249 return opInvalid 1250 } 1251 1252 func (op operator) String() string { 1253 switch op { 1254 case opAnd: 1255 return "&" 1256 case opOr: 1257 return "|" 1258 case opXor: 1259 return "XOr" // FIXME 1260 case opAdd: 1261 return "+" 1262 case opSub: 1263 return "-" 1264 case opMul: 1265 return "*" 1266 case opDiv: 1267 return "/" 1268 case opAndAnd: 1269 return "&&" 1270 case opOrOr: 1271 return "||" 1272 case opLT: 1273 return "<" 1274 case opGT: 1275 return ">" 1276 case opLE: 1277 return "<=" 1278 case opGE: 1279 return ">=" 1280 case opEq: 1281 return "==" 1282 case opNotEq: 1283 return "!=" 1284 case opRShift: 1285 return ">>" 1286 case opLShift: 1287 return "<<" 1288 } 1289 return fmt.Sprintf("%d", byte(op)) 1290 } 1291 1292 type identExpr struct { 1293 expr sqlparser.Expr 1294 name string 1295 } 1296 1297 func (expr *identExpr) sql() sqlparser.Expr { return expr.expr } 1298 func (expr *identExpr) isStatic() bool { return false } 1299 1300 func (expr *identExpr) eval(ectx *execCtx, vctx map[any]any) (r any, err error) { 1301 r, ok := vctx[expr.name] 1302 if !ok { 1303 err = fmt.Errorf("unknown field %q", expr.name) 1304 } 1305 return r, err 1306 } 1307 1308 type valueExpr struct { 1309 expr sqlparser.Expr 1310 v any 1311 } 1312 1313 func newValueExpr(expr *sqlparser.SQLVal, args []driver.NamedValue) (expression, error) { 1314 s := string(expr.Val) 1315 switch expr.Type { 1316 // case sqlparser.HexVal: // FIXME(sbinet): difference with HexNum? 1317 // v, err := strconv.ParseInt(s, 16, 64) 1318 // if err != nil { 1319 // return nil, err 1320 // } 1321 // return &valueExpr{expr: expr, v: idealInt(v)}, nil 1322 1323 case sqlparser.HexNum: 1324 v, err := strconv.ParseInt(s[len("0x"):], 16, 64) 1325 if err != nil { 1326 return nil, err 1327 } 1328 return &valueExpr{expr: expr, v: idealInt(v)}, nil 1329 1330 case sqlparser.IntVal: 1331 v, err := strconv.ParseInt(s, 10, 64) 1332 if err != nil { 1333 return nil, err 1334 } 1335 return &valueExpr{expr: expr, v: idealInt(v)}, nil 1336 1337 case sqlparser.FloatVal: 1338 v, err := strconv.ParseFloat(s, 64) 1339 if err != nil { 1340 return nil, err 1341 } 1342 return &valueExpr{expr: expr, v: idealFloat(v)}, nil 1343 1344 case sqlparser.StrVal: 1345 return &valueExpr{expr: expr, v: s}, nil 1346 1347 case sqlparser.ValArg: 1348 if !strings.HasPrefix(s, ":v") { 1349 return nil, fmt.Errorf("rsqldrv: invalid ValArg name %q", s) 1350 } 1351 i, err := strconv.ParseInt(s[len(":v"):], 10, 64) 1352 if err != nil { 1353 return nil, err 1354 } 1355 i-- // :v1 --> index-0 1356 return &valueExpr{ 1357 expr: expr, 1358 v: idealValArgFrom(args[i].Value), // FIXME(sbinet): unwrap driver.Value? 1359 }, nil 1360 1361 default: 1362 panic(fmt.Errorf("invalid SQLVal type %#v (%T)", expr, expr)) 1363 } 1364 } 1365 1366 func idealValArgFrom(v any) any { 1367 switch rv := reflect.ValueOf(v); rv.Kind() { 1368 case reflect.Int, 1369 reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: 1370 return idealInt(rv.Int()) 1371 1372 case reflect.Uint, 1373 reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: 1374 return idealUint(rv.Uint()) 1375 case reflect.Float32, reflect.Float64: 1376 return idealFloat(rv.Float()) 1377 case reflect.String: 1378 return rv.String() 1379 } 1380 panic(fmt.Errorf("rsqldrv: invalid ValArg type %#v", v)) 1381 } 1382 1383 func (expr *valueExpr) sql() sqlparser.Expr { return expr.expr } 1384 func (expr *valueExpr) isStatic() bool { return true } 1385 func (expr *valueExpr) eval(ectx *execCtx, vctx map[any]any) (any, error) { 1386 return expr.v, nil 1387 } 1388 1389 type tupleExpr struct { 1390 expr sqlparser.Expr 1391 exprs []expression 1392 } 1393 1394 func (expr *tupleExpr) sql() sqlparser.Expr { return expr.expr } 1395 func (expr *tupleExpr) isStatic() bool { 1396 for _, e := range expr.exprs { 1397 if !e.isStatic() { 1398 return false 1399 } 1400 } 1401 return true 1402 } 1403 func (expr *tupleExpr) eval(ectx *execCtx, vctx map[any]any) (any, error) { 1404 var ( 1405 o = make([]any, len(expr.exprs)) 1406 err error 1407 ) 1408 for i, e := range expr.exprs { 1409 o[i], err = e.eval(ectx, vctx) 1410 if err != nil { 1411 return nil, err 1412 } 1413 } 1414 return o, nil 1415 } 1416 1417 var ( 1418 _ expression = (*binExpr)(nil) 1419 _ expression = (*identExpr)(nil) 1420 _ expression = (*valueExpr)(nil) 1421 _ expression = (*tupleExpr)(nil) 1422 )