ALL ABOUT BIND
BIND
connects to the DB2 in which the program's LOAD module will run, reads the DBRM serially, and then performs three tasks.The first of the
BIND
tasks is an authorization check. DB2 must make sure that the programmer has the BIND
authority and the SQL authority to perform the requested SQL task (for example, updating the payroll master). When using standard authorization procedures, DB2 won't let you BIND
a DBRM if you don't have the authority to execute the SQL that's in the DBRM. This is why you may have the authorization to BIND
in development (accessing development tables) but don't have authorization to BIND
in production, where the SQL accesses production tables. The second BIND
task is a bit redundant. BIND
, like precompile, must also check the syntax of the SQL, but the BIND
check is more sophisticated. Instead of using the top, DECLARE TABLE
portion of the DCLGEN
, BIND
uses the DB2 CATALOG
table information to make sure that the column names are valid, that comparisons are numeric-to-numeric, and so on. This second syntax check occurs because you can't trust the one done by the precompiler because the precompiler check used the DCLGEN
. You could have a DCLGEN
and not have the DB2 table.The third, and most important,
BIND
task is to come up with run-time instructions for the SQL in the DBRM. Each SQL statement is parsed and all of the possible (realistic) methods for retrieving the desired columns and rows from the table are weighed, measured, and evaluated based on possible estimated I/O, CPU, and SORT
overhead. A ton of information is used as input to the BIND
process, not just CATALOG
information put there by running the RUNSTATS
utility. BIND
input includes, for example: - Indexes (what columns are in the indexes?)
- Columns (how long is this column and how much room will it occupy in a
SORT
record?) - System resources (how big are the system resources, buffer pool, and
RIDPOOL
?) - Processors (how big are they and how many engines do they have?)
- DB2 (what release is running?)
- Parameters (what are the values of the
BIND
parameters?)
BIND
sometimes generates instructions for more than one path.) This process is called optimization, and it's repeated for each SQL statement in the DBRM until all access paths are decided and the run-time instructions are created for each. As the optimizer decides on each path, writes are done to DB2.BIND
checks to see if you bound with the parameter EXPLAIN(YES);
if so, it writes documentary evidence about the chosen path to the PLAN_TABLE
and to the DSN_STATEMNT_TABLE
for your edification.BIND
also writes a lot of information to multiple CATALOG
tables, documenting the fact that the BIND
did occur. In fact, the tattooed DBRM, which is not used at run time, is moved into the CATALOG
. Objects chosen by the optimizer are documented in the CATALOG
in cross-reference tables. And BIND
parameters are recorded in the CATALOG
also.WHERE ARE THE INSTRUCTIONS?
It's interesting that the actual instructions for the access path are not written to theCATALOG
. You can't look at information in the DB2 CATALOG
to figure out whether a query will do synchronous or asynchronous reads at run time. You can't tell if the query will match on three columns of an index or five. The actual run-time instructions aren't stored in the CATALOG
. They're definitely not in the DBRM, which is input to the BIND
. So, where are they stored?This question is one of the many reasons that this column grew into two parts. Where in the heck are the run-time instructions? Should you ever use the
PLAN_TABLE
at run time? Are the run-time instructions in a package, a plan, or a version? All of the above? The infamous "it depends"? Where are the instructions stored while you wait for the LOAD module to run? Like many question come in mind.... so don't worry ....and Stay tuned for answers to these and other questions..........................
No comments:
Post a Comment