db2i_rir.cc 24.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142
/*
Licensed Materials - Property of IBM
DB2 Storage Engine Enablement
Copyright IBM Corporation 2007,2008
All rights reserved

Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met: 
 (a) Redistributions of source code must retain this list of conditions, the
     copyright notice in section {d} below, and the disclaimer following this
     list of conditions. 
 (b) Redistributions in binary form must reproduce this list of conditions, the
     copyright notice in section (d) below, and the disclaimer following this
     list of conditions, in the documentation and/or other materials provided
     with the distribution. 
 (c) The name of IBM may not be used to endorse or promote products derived from
     this software without specific prior written permission. 
 (d) The text of the required copyright notice is: 
       Licensed Materials - Property of IBM
       DB2 Storage Engine Enablement 
       Copyright IBM Corporation 2007,2008 
       All rights reserved

THIS SOFTWARE IS PROVIDED BY IBM CORPORATION "AS IS" AND ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
SHALL IBM CORPORATION BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
OF SUCH DAMAGE.
*/


#include "ha_ibmdb2i.h"

/* Helper function for records_in_range.
     Input: Bitmap of used key parts.
     Output: Number of used key parts.                                        */

static inline int getKeyCntFromMap(key_part_map keypart_map)  
{
  int cnt = 0;
  while (keypart_map)
  {
    keypart_map = keypart_map >> 1;
    cnt++;
  }
  return (cnt); 
}


/**
  @brief
  Given a starting key and an ending key, estimate the number of rows that
  will exist between the two keys.

 INPUT
    inx      Index to use
    min_key    Min key. Is NULL if no min range
    max_key    Max key. Is NULL if no max range

 NOTES
    min_key.flag can have one of the following values:
      HA_READ_KEY_EXACT    Include the key in the range
      HA_READ_AFTER_KEY    Don't include key in range

    max_key.flag can have one of the following values:  
      HA_READ_BEFORE_KEY   Don't include key in range
      HA_READ_AFTER_KEY    Include all 'end_key' values in the range

  RETURN
   HA_POS_ERROR         Error or the storage engine cannot estimate the number of rows
   1                    There are no matching keys in the given range
   n > 0                There are approximately n rows in the range
*/
ha_rows ha_ibmdb2i::records_in_range(uint inx,
                                     key_range *min_key,
                                     key_range *max_key)
{
  DBUG_ENTER("ha_ibmdb2i::records_in_range");
  int rc = 0;                 // Return code
  ha_rows rows = 0;           // Row count returned to caller of this method 
  uint32 spcLen;              // Length of space passed to DB2   
  uint32 keyCnt;              // Number of fields in the key composite
  uint32 literalCnt = 0;      // Number of literals
  uint32 boundsOff;           // Offset from beginning of space to range bounds     
  uint32 litDefOff;           // Offset from beginning of space to literal definitions
  uint32 literalsOff;         // Offset from beginning of space to literal values
  uint32 cutoff = 0;          // Early exit cutoff (currently not used)
  uint64 recCnt;              // Row count from DB2       
  uint16 rtnCode;             // Return code from DB2
  Bounds* boundsPtr;          // Pointer to a pair of range bounds      
  Bound* boundPtr;            // Pointer to a single (high or low) range bound
  LitDef* litDefPtr;          // Pointer to a literal definition
  char* literalsPtr;          // Pointer to the start of all literal values
  char* literalPtr;           // Pointer to the start of this literal value
  char* tempPtr;              // Temporary pointer
  char* tempMinPtr;           // Temporary pointer into min_key
  int minKeyCnt = 0;          // Number of fields in the min_key composite 
  int maxKeyCnt = 0;          // Number of fields in the max_key composite
  size_t tempLen = 0;         // Temporary length
  uint16 DB2FieldWidth = 0;   // DB2 field width
  uint32 workFieldLen = 0;    // Length of workarea needed for CCSID conversions
  bool overrideInclusion;     // Indicator for inclusion/exclusion     
  char* endOfLiteralPtr;      // Pointer to the end of this literal
  char* endOfMinPtr;          // Pointer to end of min_key
  uint16 endByte = 0;         // End byte of char or graphic literal (padding not included) 
  bool reuseLiteral;          // Indicator that hi and lo bounds use same literal
  char* minPtr = NULL;               // Work pointer for traversing min_key  
  char* maxPtr = NULL;               // Work pointer for traversing max_key    
  /*                                                                                  
     Handle the special case of 'x < null' anywhere in the key range. There are
     no values less than null, but return 1 so that MySQL does not assume
     the empty set for the query. 
                                                                              */
  if (min_key != NULL && max_key != NULL &&
      min_key->flag == HA_READ_AFTER_KEY && max_key->flag == HA_READ_BEFORE_KEY && 
      min_key->length == max_key->length &&
     (memcmp((uchar*)min_key->key,(uchar*)max_key->key,min_key->length)==0))
  {
    DBUG_PRINT("ha_ibmdb2i::records_in_range",("Estimate 1 row for key %d; special case: < null", inx));
    DBUG_RETURN((ha_rows) 1 );                               
  }
  /*                                                                                  
     Determine the number of fields in the key composite.                             
                                                                              */

  if (min_key)
  {
    minKeyCnt = getKeyCntFromMap(min_key->keypart_map);
    minPtr = (char*)min_key->key;
  }
  if (max_key)
  {
    maxKeyCnt = getKeyCntFromMap(max_key->keypart_map);
    maxPtr = (char*)max_key->key;
  }
  keyCnt = maxKeyCnt >= minKeyCnt ? maxKeyCnt : minKeyCnt;

143 144 145 146 147 148 149 150 151 152 153
  /*
     Handle the special case where MySQL does not pass either a min or max
     key range. In this case, set the key count to 1 (knowing that there
     is at least one key field) to flow through and create one bounds structure.
     When both the min and max key ranges are nil, the bounds structure will
     specify positive and negative infinity and DB2 will estimate the total 
     number of rows.                                                                                                                                                            */

  if (keyCnt == 0)
    keyCnt = 1;

154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209
  /*                                                                               
     Allocate the space needed to pass range information to DB2. The            
     space must be large enough to store the following:                         
        - one pair of bounds (high and low) per field in the key composite            
        - one literal definition per literal value                              
        - the literal values                                                    
        - work area for literal CCSID conversions                                     
     Since we don't know yet how many of these structures are needed,           
     allocate enough space for the maximum that we will possibly need.        
     The workarea for the literal conversion must be big enough to hold the     
     largest of the DB2 key fields.                                             
                                                                              */
  KEY& curKey = table->key_info[inx];

  for (int i = 0; i < keyCnt; i++)  
  {
    DB2FieldWidth =
      db2Table->db2Field(curKey.key_part[i].field->field_index).getByteLengthInRecord();  
    if (DB2FieldWidth > workFieldLen)
      workFieldLen = DB2FieldWidth;      // Get length of largest DB2 field
    tempLen = tempLen + DB2FieldWidth;   // Tally the DB2 field lengths
  }
  spcLen = (sizeof(Bounds)*keyCnt) + (sizeof(LitDef)*keyCnt*2) + (tempLen*2) + workFieldLen;

  ValidatedPointer<char>  spcPtr(spcLen); // Pointer to space passed to DB2
  memset(spcPtr, 0, spcLen);             // Clear the allocated space 
  /*                                                                            
     Set addressability to the various sections of the DB2 interface space.     
                                                                              */
  boundsOff = 0;                         // Range bounds are at the start of the space
  litDefOff = sizeof(Bounds) * keyCnt;   // Literal defs follow all the range bounds       
  literalsOff = litDefOff + (sizeof(LitDef) * keyCnt * 2); // Literal values are last
  boundsPtr = (Bounds_t*)(void*)spcPtr;  // Address first bounds structure
  tempPtr = (char*)((char*)spcPtr + litDefOff);
  litDefPtr = (LitDef_t*)tempPtr;        // Address first literal definition
  tempPtr = (char*)((char*)spcPtr + literalsOff); 
  literalsPtr = (char*)tempPtr;          // Address start of literal values
  literalPtr = literalsPtr;              // Address first literal value 
  /*                                                                             
     For each key part, build the low (min) and high (max) DB2 range bounds.  
     If literals are specified in the MySQL range, build DB2 literal          
     definitions and store the literal values for access by DB2.              
                                                                              
     If no value is specified for a key part, assume infinity.  Negative      
     infinity will cause processing to start at the first index entry.        
     Positive infinity will cause processing to end at the last index entry.  
     When infinity is specified in a bound, inclusion/exclusion and position  
     are ignored, and there is no literal definition or literal value for     
     the bound.                                                               
                                                                              
     If the keypart value is null, the null indicator is set in the range     
     bound and the other fields in the bound are ignored. When the bound is   
     null, only index entries with the null value will be included in the     
     estimate. If one bound is null, both bounds must be null. When the bound 
     is not null, the data offset and length must be set, and the literal     
     value stored for access by DB2.                                          
210
                                                                                         */
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310
  for (int partsInUse = 0; partsInUse < keyCnt; ++partsInUse)
  {
   Field *field= curKey.key_part[partsInUse].field;
   overrideInclusion = false;
   reuseLiteral = false;
   endOfLiteralPtr = NULL;
   /*
    Build the low bound for the key range.                                       
                                                                             */
    if ((partsInUse + 1) > minKeyCnt)                             // if no min_key info for this part
      boundsPtr->LoBound.Infinity[0] = QMY_NEG_INFINITY;          // select...where 3 between x and y    
    else
    {
      if ((curKey.key_part[partsInUse].null_bit) && (char*)minPtr[0])     
      {                                                           // min_key is null
        if (max_key == NULL ||
           ((partsInUse + 1) > maxKeyCnt))                        // select...where x='ab' and y=null and z != 'c'
          boundsPtr->LoBound.Infinity[0] = QMY_NEG_INFINITY;      // select...where x not null or
                                                                  // select...where x > null
        else                                                      // max_key is not null 
        {
          if (min_key->flag == HA_READ_KEY_EXACT) 
            boundsPtr->LoBound.IsNull[0] = QMY_YES;               // select...where x is null
          else                                                 
          {
            if ((char*)maxPtr[0])                                       
              boundsPtr->LoBound.IsNull[0] = QMY_YES;             // select...where a = null and b < 5 (max-before)
                                                                  // select...where a='a' and b is null and c !='a' (max-after)
            else 
              boundsPtr->LoBound.Infinity[0] = QMY_NEG_INFINITY;  // select...where x < y
          }
        }                                                         // end min_key is null
      }
      else                                                        // min_key is not null 
      {
        if (literalCnt) litDefPtr = litDefPtr + 1;
        literalCnt = literalCnt + 1;
        boundsPtr->LoBound.Position = literalCnt;
        /*
           Determine inclusion or exclusion.
                                                                                               */
        if (min_key->flag == HA_READ_KEY_EXACT ||                //select...where a like 'this%'
            
            /* An example for the following conditions is 'select...where a = 5 and b > null'. */
 
            (max_key &&
            (memcmp((uchar*)minPtr,(uchar*)maxPtr,
                    curKey.key_part[partsInUse].store_length)==0))) 
   
        {
          if ((min_key->flag != HA_READ_KEY_EXACT) ||
              (max_key &&
              (memcmp((uchar*)minPtr,(uchar*)maxPtr,
                    curKey.key_part[partsInUse].store_length)==0)))
            overrideInclusion = true;                     // Need inclusion for both min and max 
        }
        else
          boundsPtr->LoBound.Embodiment[0] = QMY_EXCLUSION;
        litDefPtr->FieldNbr = field->field_index + 1;
        DB2Field& db2Field = db2Table->db2Field(field->field_index);
        litDefPtr->DataType = db2Field.getType();
        /*
           Convert the literal to DB2 format.  
                                                                                   */
        rc = convertMySQLtoDB2(field,
                 db2Field,
                 literalPtr,
                 (uchar*)minPtr+((curKey.key_part[partsInUse].null_bit)? 1 : 0));
        if (rc != 0) break;
        litDefPtr->Offset = (uint32_t)(literalPtr - literalsPtr);
        litDefPtr->Length = db2Field.getByteLengthInRecord();
        tempLen = litDefPtr->Length;
        /*
           Do additional conversion of a character or graphic value.
                                                                                 */
        CHARSET_INFO* fieldCharSet = field->charset();                                    
        if ((field->type() != MYSQL_TYPE_BIT) &&           // Don't do conversion on BIT data
            (field->charset() != &my_charset_bin) &&       // Don't do conversion on BINARY data
            (litDefPtr->DataType == QMY_CHAR || litDefPtr->DataType == QMY_VARCHAR ||
             litDefPtr->DataType == QMY_GRAPHIC || litDefPtr->DataType == QMY_VARGRAPHIC))
        {
           if (litDefPtr->DataType == QMY_VARCHAR ||
               litDefPtr->DataType == QMY_VARGRAPHIC) 
             tempPtr = literalPtr + sizeof(uint16);
           else
             tempPtr = literalPtr;
           /* The following code checks to determine if MySQL is passing a
              partial key. DB2 will accept a partial field value, but only
              in the last field position of the key composite (and only if
              there is no ICU sort sequence on the index).                  */
           tempMinPtr = (char*)minPtr+((curKey.key_part[partsInUse].null_bit)? 1 : 0);
           if (field->type() == MYSQL_TYPE_VARCHAR)
           {
             /* MySQL always stores key lengths as 2 bytes, little-endian. */
               tempLen = *(uint8*)tempMinPtr + ((*(uint8*)(tempMinPtr+1)) << 8);
               tempMinPtr = (char*)((char*)tempMinPtr + 2);
           }
           else
             tempLen = field->field_length;                         

311 312 313
           /* Determine if we are dealing with a partial key and if so, find the end of the partial key. */
           if (litDefPtr->DataType == QMY_CHAR || litDefPtr->DataType == QMY_VARCHAR )
           { /* Char or varchar.  If UTF8, no conversion is done to DB2 graphic.) */
314 315
               endOfMinPtr = (char*)memchr(tempMinPtr,field->charset()->min_sort_char,tempLen);
               if (endOfMinPtr)
316
                 endOfLiteralPtr = tempPtr + ((uint32_t)(endOfMinPtr - tempMinPtr));
317 318 319
           }
           else
           {
320 321 322 323 324 325 326 327 328 329 330 331 332
              if (strncmp(fieldCharSet->csname, "utf8", sizeof("utf8")) == 0)
              {  /* The MySQL charset is UTF8 but we are converting to graphic on DB2. Divide number of UTF8 bytes
                    by 3 to get the number of characters, then multiple by 2 for double-byte graphic.*/
               endOfMinPtr = (char*)memchr(tempMinPtr,field->charset()->min_sort_char,tempLen);
               if (endOfMinPtr)
                 endOfLiteralPtr = tempPtr + (((uint32_t)((endOfMinPtr - tempMinPtr)) / 3) * 2);
              } 
              else
              { /* The DB2 data type is graphic or vargraphic, and we are not converting from UTF8 to graphic. */  
                endOfMinPtr = (char*)wmemchr((wchar_t*)tempMinPtr,field->charset()->min_sort_char,tempLen/2);
                if (endOfMinPtr)
                  endOfLiteralPtr = tempPtr + (endOfMinPtr - tempMinPtr);
              }
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375
           }
           /* Enforce here that a partial is only allowed on the last field position 
              of the key composite                                                    */
           if (endOfLiteralPtr)
           {
             if ((partsInUse + 1) < minKeyCnt)   
             {
               rc = HA_POS_ERROR;
               break;
             }
             endByte = endOfLiteralPtr - tempPtr;
             /* We're making an assumption that if MySQL gives us a partial key, 
                 the length of the partial is the same for both the min_key and max_key.      */
           }  
        }
        literalPtr = literalPtr + litDefPtr->Length;  // Bump pointer for next literal
      }
      /* If there is a max_key value for this field, and if the max_key value is 
         the same as the min_key value, then the low bound literal can be reused              
         for the high bound literal. This eliminates the overhead of copying and
         converting the same value twice.                                        */ 
      if (max_key && ((partsInUse + 1) <= maxKeyCnt) && 
          (memcmp((uchar*)minPtr,(uchar*)maxPtr,
                    curKey.key_part[partsInUse].store_length)==0 || endOfLiteralPtr))   
        reuseLiteral = true;
      minPtr += curKey.key_part[partsInUse].store_length;
    }
   /*
      Build the high bound for the key range. 
                                                                              */
    if (max_key == NULL || ((partsInUse + 1) > maxKeyCnt))                                         
      boundsPtr->HiBound.Infinity[0] = QMY_POS_INFINITY;     
    else                                                      
    {
      if ((curKey.key_part[partsInUse].null_bit) && (char*)maxPtr[0])
      {
        if (min_key == NULL)
          boundsPtr->HiBound.Infinity[0] = QMY_POS_INFINITY;   
        else
          boundsPtr->HiBound.IsNull[0] = QMY_YES;             // select...where x is null
      }  
      else                                                    // max_key field is not null
      {
376 377 378 379 380
        if (boundsPtr->LoBound.IsNull[0] == QMY_YES)          // select where x < 10 or x is null
        {
          rc = HA_POS_ERROR;
          break;
        }
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407
        if (!reuseLiteral)                                    
        {  
          if (literalCnt)             
            litDefPtr = litDefPtr + 1;
          literalCnt = literalCnt + 1;
          litDefPtr->FieldNbr = field->field_index + 1;
          DB2Field& db2Field = db2Table->db2Field(field->field_index);
          litDefPtr->DataType = db2Field.getType();
        /*
           Convert the literal to DB2 format
                                                                                               */
          rc = convertMySQLtoDB2(field,
                 db2Field,
                 literalPtr,
                 (uchar*)maxPtr+((curKey.key_part[partsInUse].null_bit)? 1 : 0));
          if (rc != 0) break;
          litDefPtr->Offset = (uint32_t)(literalPtr - literalsPtr);
          litDefPtr->Length = db2Field.getByteLengthInRecord();
          tempLen = litDefPtr->Length;
          /*
             Now convert a character or graphic value.
                                                                                 */
          if ((field->type() != MYSQL_TYPE_BIT) &&     
             (litDefPtr->DataType == QMY_CHAR || litDefPtr->DataType == QMY_VARCHAR ||
              litDefPtr->DataType == QMY_GRAPHIC || litDefPtr->DataType == QMY_VARGRAPHIC))
          {
             if (litDefPtr->DataType == QMY_VARCHAR || litDefPtr->DataType == QMY_VARGRAPHIC)
408
             {
409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
                tempPtr = literalPtr + sizeof(uint16);
             }
             else
               tempPtr = literalPtr;
          }
          literalPtr = literalPtr + litDefPtr->Length;   // Bump pointer for next literal
        }
        boundsPtr->HiBound.Position = literalCnt;
        if (max_key->flag == HA_READ_BEFORE_KEY && !overrideInclusion)
          boundsPtr->HiBound.Embodiment[0] = QMY_EXCLUSION;
      }
      maxPtr += curKey.key_part[partsInUse].store_length;
    }
  /*                                                                            
     Bump to the next field in the key composite.                                     
                                                                              */

    if ((partsInUse+1) < keyCnt)
      boundsPtr = boundsPtr + 1;
  }

  /*                                                                            
     Call DB2 to estimate the number of rows in the key range.                  
                                                                              */
  if (rc == 0)
  {    
    rc = db2i_ileBridge::getBridgeForThread()->recordsInRange((indexHandles[inx] ? indexHandles[inx] : db2Table->indexFile(inx)->getMasterDefnHandle()),
                                                            spcPtr,  
                                                            keyCnt,  
                                                            literalCnt,
                                                            boundsOff,
                                                            litDefOff,
                                                            literalsOff,
                                                            cutoff,
                                                            (uint32_t)(literalPtr - (char*)spcPtr),            
                                                            endByte,
                                                            &recCnt,
                                                            &rtnCode);
  }
    /*                                                                            
     Set the row count and return.                                            
     Beware that if this method returns a zero row count, MySQL assumes the
     result set for the query is zero; never return a zero row count.                      
                                                                              */
  if ((rc == 0) && (rtnCode == QMY_SUCCESS || rtnCode == QMY_EARLY_EXIT))
  {
    rows = recCnt ? (ha_rows)recCnt : 1;                                                 
  }
 
  rows = (rows > 0 ? rows : HA_POS_ERROR);

  setIndexReadEstimate(inx, rows);
  
  DBUG_PRINT("ha_ibmdb2i::recordsInRange",("Estimate %d rows for key %d", uint32(rows), inx));  
  
  DBUG_RETURN(rows);                              
}