← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/sql_show.cc

  • Committer: Brian Aker
  • Date: 2008-07-13 22:45:08 UTC
  • Revision ID: brian@tangent.org-20080713224508-hb20z4okblotb39a
longlong replacement

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/sql_show.cc
893
893
    {
894
894
      char *end;
895
895
      packet->append(STRING_WITH_LEN(" AUTO_INCREMENT="));
896
 
      end= longlong10_to_str(create_info.auto_increment_value, buff,10);
 
896
      end= int64_t10_to_str(create_info.auto_increment_value, buff,10);
897
897
      packet->append(buff, (uint) (end - buff));
898
898
    }
899
899
 
921
921
    {
922
922
      char *end;
923
923
      packet->append(STRING_WITH_LEN(" MIN_ROWS="));
924
 
      end= longlong10_to_str(share->min_rows, buff, 10);
 
924
      end= int64_t10_to_str(share->min_rows, buff, 10);
925
925
      packet->append(buff, (uint) (end- buff));
926
926
    }
927
927
 
929
929
    {
930
930
      char *end;
931
931
      packet->append(STRING_WITH_LEN(" MAX_ROWS="));
932
 
      end= longlong10_to_str(share->max_rows, buff, 10);
 
932
      end= int64_t10_to_str(share->max_rows, buff, 10);
933
933
      packet->append(buff, (uint) (end - buff));
934
934
    }
935
935
 
937
937
    {
938
938
      char *end;
939
939
      packet->append(STRING_WITH_LEN(" AVG_ROW_LENGTH="));
940
 
      end= longlong10_to_str(share->avg_row_length, buff,10);
 
940
      end= int64_t10_to_str(share->avg_row_length, buff,10);
941
941
      packet->append(buff, (uint) (end - buff));
942
942
    }
943
943
 
969
969
    {
970
970
      char *end;
971
971
      packet->append(STRING_WITH_LEN(" KEY_BLOCK_SIZE="));
972
 
      end= longlong10_to_str(table->s->key_block_size, buff, 10);
 
972
      end= int64_t10_to_str(table->s->key_block_size, buff, 10);
973
973
      packet->append(buff, (uint) (end - buff));
974
974
    }
975
975
    table->file->append_create_info(packet);
1074
1074
      table->s->key_block_size != key_info->block_size)
1075
1075
  {
1076
1076
    packet->append(STRING_WITH_LEN(" KEY_BLOCK_SIZE="));
1077
 
    end= longlong10_to_str(key_info->block_size, buff, 10);
 
1077
    end= int64_t10_to_str(key_info->block_size, buff, 10);
1078
1078
    packet->append(buff, (uint) (end - buff));
1079
1079
  }
1080
1080
 
1249
1249
 
1250
1250
      restore_record(table, s->default_values);
1251
1251
      /* ID */
1252
 
      table->field[0]->store((longlong) tmp->thread_id, TRUE);
 
1252
      table->field[0]->store((int64_t) tmp->thread_id, TRUE);
1253
1253
      /* USER */
1254
1254
      val= tmp_sctx->user ? tmp_sctx->user :
1255
1255
            (tmp->system_thread ? "system user" : "unauthenticated user");
1579
1579
          value= ((char *) status_var + (uint64_t) value);
1580
1580
          /* fall through */
1581
1581
        case SHOW_LONGLONG:
1582
 
          end= longlong10_to_str(*(longlong*) value, buff, 10);
 
1582
          end= int64_t10_to_str(*(int64_t*) value, buff, 10);
1583
1583
          break;
1584
1584
        case SHOW_HA_ROWS:
1585
 
          end= longlong10_to_str((longlong) *(ha_rows*) value, buff, 10);
 
1585
          end= int64_t10_to_str((int64_t) *(ha_rows*) value, buff, 10);
1586
1586
          break;
1587
1587
        case SHOW_BOOL:
1588
1588
          end= strmov(buff, *(bool*) value ? "ON" : "OFF");
1620
1620
          break;
1621
1621
        case SHOW_KEY_CACHE_LONGLONG:
1622
1622
          value= (char*) dflt_key_cache + (ulong)value;
1623
 
          end= longlong10_to_str(*(longlong*) value, buff, 10);
 
1623
          end= int64_t10_to_str(*(int64_t*) value, buff, 10);
1624
1624
          break;
1625
1625
        case SHOW_UNDEF:
1626
1626
          break;                                        // Return empty string
2847
2847
    }
2848
2848
    tmp_buff= (char *) ha_resolve_storage_engine_name(tmp_db_type);
2849
2849
    table->field[4]->store(tmp_buff, strlen(tmp_buff), cs);
2850
 
    table->field[5]->store((longlong) share->frm_version, TRUE);
 
2850
    table->field[5]->store((int64_t) share->frm_version, TRUE);
2851
2851
 
2852
2852
    ptr=option_buff;
2853
2853
    if (share->min_rows)
2854
2854
    {
2855
2855
      ptr=strmov(ptr," min_rows=");
2856
 
      ptr=longlong10_to_str(share->min_rows,ptr,10);
 
2856
      ptr=int64_t10_to_str(share->min_rows,ptr,10);
2857
2857
    }
2858
2858
    if (share->max_rows)
2859
2859
    {
2860
2860
      ptr=strmov(ptr," max_rows=");
2861
 
      ptr=longlong10_to_str(share->max_rows,ptr,10);
 
2861
      ptr=int64_t10_to_str(share->max_rows,ptr,10);
2862
2862
    }
2863
2863
    if (share->avg_row_length)
2864
2864
    {
2865
2865
      ptr=strmov(ptr," avg_row_length=");
2866
 
      ptr=longlong10_to_str(share->avg_row_length,ptr,10);
 
2866
      ptr=int64_t10_to_str(share->avg_row_length,ptr,10);
2867
2867
    }
2868
2868
    if (share->db_create_options & HA_OPTION_PACK_KEYS)
2869
2869
      ptr=strmov(ptr," pack_keys=1");
2936
2936
      table->field[6]->store(tmp_buff, strlen(tmp_buff), cs);
2937
2937
      if (!tables->schema_table)
2938
2938
      {
2939
 
        table->field[7]->store((longlong) file->stats.records, TRUE);
 
2939
        table->field[7]->store((int64_t) file->stats.records, TRUE);
2940
2940
        table->field[7]->set_notnull();
2941
2941
      }
2942
 
      table->field[8]->store((longlong) file->stats.mean_rec_length, TRUE);
2943
 
      table->field[9]->store((longlong) file->stats.data_file_length, TRUE);
 
2942
      table->field[8]->store((int64_t) file->stats.mean_rec_length, TRUE);
 
2943
      table->field[9]->store((int64_t) file->stats.data_file_length, TRUE);
2944
2944
      if (file->stats.max_data_file_length)
2945
2945
      {
2946
 
        table->field[10]->store((longlong) file->stats.max_data_file_length,
 
2946
        table->field[10]->store((int64_t) file->stats.max_data_file_length,
2947
2947
                                TRUE);
2948
2948
      }
2949
 
      table->field[11]->store((longlong) file->stats.index_file_length, TRUE);
2950
 
      table->field[12]->store((longlong) file->stats.delete_length, TRUE);
 
2949
      table->field[11]->store((int64_t) file->stats.index_file_length, TRUE);
 
2950
      table->field[12]->store((int64_t) file->stats.delete_length, TRUE);
2951
2951
      if (show_table->found_next_number_field)
2952
2952
      {
2953
 
        table->field[13]->store((longlong) file->stats.auto_increment_value,
 
2953
        table->field[13]->store((int64_t) file->stats.auto_increment_value,
2954
2954
                                TRUE);
2955
2955
        table->field[13]->set_notnull();
2956
2956
      }
2977
2977
      }
2978
2978
      if (file->ha_table_flags() & (ulong) HA_HAS_CHECKSUM)
2979
2979
      {
2980
 
        table->field[18]->store((longlong) file->checksum(), TRUE);
 
2980
        table->field[18]->store((int64_t) file->checksum(), TRUE);
2981
2981
        table->field[18]->set_notnull();
2982
2982
      }
2983
2983
    }
3024
3024
    uint32 octet_max_length= field->max_display_length();
3025
3025
    if (is_blob && octet_max_length != (uint32) 4294967295U)
3026
3026
      octet_max_length /= field->charset()->mbmaxlen;
3027
 
    longlong char_max_len= is_blob ? 
3028
 
      (longlong) octet_max_length / field->charset()->mbminlen :
3029
 
      (longlong) octet_max_length / field->charset()->mbmaxlen;
 
3027
    int64_t char_max_len= is_blob ? 
 
3028
      (int64_t) octet_max_length / field->charset()->mbminlen :
 
3029
      (int64_t) octet_max_length / field->charset()->mbmaxlen;
3030
3030
    /* CHARACTER_MAXIMUM_LENGTH column*/
3031
3031
    table->field[offset + 1]->store(char_max_len, TRUE);
3032
3032
    table->field[offset + 1]->set_notnull();
3033
3033
    /* CHARACTER_OCTET_LENGTH column */
3034
 
    table->field[offset + 2]->store((longlong) octet_max_length, TRUE);
 
3034
    table->field[offset + 2]->store((int64_t) octet_max_length, TRUE);
3035
3035
    table->field[offset + 2]->set_notnull();
3036
3036
  }
3037
3037
 
3065
3065
  /* NUMERIC_PRECISION column */
3066
3066
  if (field_length >= 0)
3067
3067
  {
3068
 
    table->field[offset + 3]->store((longlong) field_length, TRUE);
 
3068
    table->field[offset + 3]->store((int64_t) field_length, TRUE);
3069
3069
    table->field[offset + 3]->set_notnull();
3070
3070
  }
3071
3071
  /* NUMERIC_SCALE column */
3072
3072
  if (decimals >= 0)
3073
3073
  {
3074
 
    table->field[offset + 4]->store((longlong) decimals, TRUE);
 
3074
    table->field[offset + 4]->store((int64_t) decimals, TRUE);
3075
3075
    table->field[offset + 4]->set_notnull();
3076
3076
  }
3077
3077
  if (field->has_charset())
3174
3174
    table->field[2]->store(table_name->str, table_name->length, cs);
3175
3175
    table->field[3]->store(field->field_name, strlen(field->field_name),
3176
3176
                           cs);
3177
 
    table->field[4]->store((longlong) count, TRUE);
 
3177
    table->field[4]->store((int64_t) count, TRUE);
3178
3178
 
3179
3179
    if (get_field_default_value(thd, timestamp_field, field, &type, 0))
3180
3180
    {
3243
3243
      table->field[1]->store(tmp_cs->name, strlen(tmp_cs->name), scs);
3244
3244
      comment= tmp_cs->comment ? tmp_cs->comment : "";
3245
3245
      table->field[2]->store(comment, strlen(comment), scs);
3246
 
      table->field[3]->store((longlong) tmp_cs->mbmaxlen, TRUE);
 
3246
      table->field[3]->store((int64_t) tmp_cs->mbmaxlen, TRUE);
3247
3247
      if (schema_table_store_record(thd, table))
3248
3248
        return 1;
3249
3249
    }
3279
3279
        restore_record(table, s->default_values);
3280
3280
        table->field[0]->store(tmp_cl->name, strlen(tmp_cl->name), scs);
3281
3281
        table->field[1]->store(tmp_cl->csname , strlen(tmp_cl->csname), scs);
3282
 
        table->field[2]->store((longlong) tmp_cl->number, TRUE);
 
3282
        table->field[2]->store((int64_t) tmp_cl->number, TRUE);
3283
3283
        tmp_buff= (tmp_cl->state & MY_CS_PRIMARY) ? "Yes" : "";
3284
3284
        table->field[3]->store(tmp_buff, strlen(tmp_buff), scs);
3285
3285
        tmp_buff= (tmp_cl->state & MY_CS_COMPILED)? "Yes" : "";
3286
3286
        table->field[4]->store(tmp_buff, strlen(tmp_buff), scs);
3287
 
        table->field[5]->store((longlong) tmp_cl->strxfrm_multiply, TRUE);
 
3287
        table->field[5]->store((int64_t) tmp_cl->strxfrm_multiply, TRUE);
3288
3288
        if (schema_table_store_record(thd, table))
3289
3289
          return 1;
3290
3290
      }
3362
3362
        restore_record(table, s->default_values);
3363
3363
        table->field[1]->store(db_name->str, db_name->length, cs);
3364
3364
        table->field[2]->store(table_name->str, table_name->length, cs);
3365
 
        table->field[3]->store((longlong) ((key_info->flags &
 
3365
        table->field[3]->store((int64_t) ((key_info->flags &
3366
3366
                                            HA_NOSAME) ? 0 : 1), TRUE);
3367
3367
        table->field[4]->store(db_name->str, db_name->length, cs);
3368
3368
        table->field[5]->store(key_info->name, strlen(key_info->name), cs);
3369
 
        table->field[6]->store((longlong) (j+1), TRUE);
 
3369
        table->field[6]->store((int64_t) (j+1), TRUE);
3370
3370
        str=(key_part->field ? key_part->field->field_name :
3371
3371
             "?unknown field?");
3372
3372
        table->field[7]->store(str, strlen(str), cs);
3384
3384
          {
3385
3385
            ha_rows records=(show_table->file->stats.records /
3386
3386
                             key->rec_per_key[j]);
3387
 
            table->field[9]->store((longlong) records, TRUE);
 
3387
            table->field[9]->store((int64_t) records, TRUE);
3388
3388
            table->field[9]->set_notnull();
3389
3389
          }
3390
3390
          str= show_table->file->index_type(i);
3394
3394
             key_part->length !=
3395
3395
             show_table->s->field[key_part->fieldnr-1]->key_length()))
3396
3396
        {
3397
 
          table->field[10]->store((longlong) key_part->length /
 
3397
          table->field[10]->store((int64_t) key_part->length /
3398
3398
                                  key_part->field->charset()->mbmaxlen, TRUE);
3399
3399
          table->field[10]->set_notnull();
3400
3400
        }
3497
3497
void store_key_column_usage(TABLE *table, LEX_STRING *db_name,
3498
3498
                            LEX_STRING *table_name, const char *key_name,
3499
3499
                            uint key_len, const char *con_type, uint con_len,
3500
 
                            longlong idx)
 
3500
                            int64_t idx)
3501
3501
{
3502
3502
  CHARSET_INFO *cs= system_charset_info;
3503
3503
  table->field[1]->store(db_name->str, db_name->length, cs);
3505
3505
  table->field[4]->store(db_name->str, db_name->length, cs);
3506
3506
  table->field[5]->store(table_name->str, table_name->length, cs);
3507
3507
  table->field[6]->store(con_type, con_len, cs);
3508
 
  table->field[7]->store((longlong) idx, TRUE);
 
3508
  table->field[7]->store((int64_t) idx, TRUE);
3509
3509
}
3510
3510
 
3511
3511
 
3549
3549
                                 strlen(key_info->name), 
3550
3550
                                 key_part->field->field_name, 
3551
3551
                                 strlen(key_part->field->field_name),
3552
 
                                 (longlong) f_idx);
 
3552
                                 (int64_t) f_idx);
3553
3553
          if (schema_table_store_record(thd, table))
3554
3554
            return(1);
3555
3555
        }
3575
3575
                               f_key_info->forein_id->str,
3576
3576
                               f_key_info->forein_id->length,
3577
3577
                               f_info->str, f_info->length,
3578
 
                               (longlong) f_idx);
3579
 
        table->field[8]->store((longlong) f_idx, TRUE);
 
3578
                               (int64_t) f_idx);
 
3579
        table->field[8]->store((int64_t) f_idx, TRUE);
3580
3580
        table->field[8]->set_notnull();
3581
3581
        table->field[9]->store(f_key_info->referenced_db->str,
3582
3582
                               f_key_info->referenced_db->length,
3613
3613
    restore_record(table, s->default_values);
3614
3614
    table->field[0]->store(open_list->db, strlen(open_list->db), cs);
3615
3615
    table->field[1]->store(open_list->table, strlen(open_list->table), cs);
3616
 
    table->field[2]->store((longlong) open_list->in_use, TRUE);
3617
 
    table->field[3]->store((longlong) open_list->locked, TRUE);
 
3616
    table->field[2]->store((int64_t) open_list->in_use, TRUE);
 
3617
    table->field[3]->store((int64_t) open_list->locked, TRUE);
3618
3618
    if (schema_table_store_record(thd, table))
3619
3619
      return(1);
3620
3620
  }
3901
3901
        return(NULL);
3902
3902
      break;
3903
3903
    case MYSQL_TYPE_NEWDECIMAL:
3904
 
      if (!(item= new Item_decimal((longlong) fields_info->value, false)))
 
3904
      if (!(item= new Item_decimal((int64_t) fields_info->value, false)))
3905
3905
      {
3906
3906
        return(0);
3907
3907
      }