Improve quality of life while implementing core features.
```
Welcome to Limbo SQL shell!
> .opcodes
Abortable
---------
Verify that an Abort can happen. Assert if an Abort at this point might cause database corruption. This opcode only appears in debugging builds. An Abort is safe if either there have been no writes, or if there is an active statement journal.
Add
---------
Add the value in register P1 to the value in register P2 and store the result in register P3. If either input is NULL, the result is NULL.
AddImm
---------
Add the constant P2 to the value in register P1. The result is always an integer. To force any register to be an integer, just add 0.
Affinity
---------
Apply affinities to a range of P2 registers starting with P1. P4 is a string that is P2 characters long. The N-th character of the string indicates the column affinity that should be used for the N-th memory cell in the range.
AggFinal
---------
P1 is the memory location that is the accumulator for an aggregate or window function. Execute the finalizer function for an aggregate and store the result in P1. P2 is the number of arguments that the step function takes and P4 is a pointer to the FuncDef for this function. The P2 argument is not used by this opcode. It is only there to disambiguate functions that can take varying numbers of arguments. The P4 argument is only needed for the case where the step function was not previously called.
```
It can also search for specific opcode:
```
> .opcodes yield
Yield
---------
Swap the program counter with the value in register P1. This has the effect of yielding to a coroutine. If the coroutine that is launched by this instruction ends with Yield or Return then continue to the next instruction. But if the coroutine launched by this instruction ends with EndCoroutine, then jump to P2 rather than continuing with the next instruction. See also: InitCoroutine
```
The SQLite documentation explicitly says that P1, P2, and P3 are 32-bit
signed integers. P4 is a value, and P5 is a 16-bit unsigned integer.
Although we use different types for operands, the `EXPLAIN` output
should be compatible with SQLite and, therefore, use those types.
This introduces an intermediate `Select` struct, which hopefully makes
the codegen a bit simpler by transforming the complext AST to something
more straight-forward.
Instead, use the `ast::<type>` qualifier in the code to make it more
explicit where we're dealing with AST and where we're dealing with our
own data types. Paves the way for a `Select` struct.
