← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/opt_range.cc

Renamed __attribute__((__unused__)) to __attribute__((unused)). 
It takes up a few less chars, but also seems to be the standard usage.

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/opt_range.cc
1886
1886
  /* Table read plans are allocated on MEM_ROOT and are never deleted */
1887
1887
  static void *operator new(size_t size, MEM_ROOT *mem_root)
1888
1888
  { return (void*) alloc_root(mem_root, (uint) size); }
1889
 
  static void operator delete(void *ptr __attribute__((__unused__)),
1890
 
                              size_t size __attribute__((__unused__)))
 
1889
  static void operator delete(void *ptr __attribute__((unused)),
 
1890
                              size_t size __attribute__((unused)))
1891
1891
    { TRASH(ptr, size); }
1892
 
  static void operator delete(void *ptr __attribute__((__unused__)),
1893
 
                              MEM_ROOT *mem_root __attribute__((__unused__)))
 
1892
  static void operator delete(void *ptr __attribute__((unused)),
 
1893
                              MEM_ROOT *mem_root __attribute__((unused)))
1894
1894
    { /* Never called */ }
1895
1895
  virtual ~TABLE_READ_PLAN() {}               /* Remove gcc warning */
1896
1896
 
1922
1922
  virtual ~TRP_RANGE() {}                     /* Remove gcc warning */
1923
1923
 
1924
1924
  QUICK_SELECT_I *make_quick(PARAM *param,
1925
 
                             bool retrieve_full_rows __attribute__((__unused__)),
 
1925
                             bool retrieve_full_rows __attribute__((unused)),
1926
1926
                             MEM_ROOT *parent_alloc)
1927
1927
  {
1928
1928
    QUICK_RANGE_SELECT *quick;
3601
3601
 
3602
3602
 
3603
3603
QUICK_SELECT_I *TRP_INDEX_MERGE::make_quick(PARAM *param,
3604
 
                                            bool retrieve_full_rows __attribute__((__unused__)),
3605
 
                                            MEM_ROOT *parent_alloc __attribute__((__unused__)))
 
3604
                                            bool retrieve_full_rows __attribute__((unused)),
 
3605
                                            MEM_ROOT *parent_alloc __attribute__((unused)))
3606
3606
{
3607
3607
  QUICK_INDEX_MERGE_SELECT *quick_imerge;
3608
3608
  QUICK_RANGE_SELECT *quick;
3678
3678
 
3679
3679
 
3680
3680
QUICK_SELECT_I *TRP_ROR_UNION::make_quick(PARAM *param,
3681
 
                                          bool retrieve_full_rows __attribute__((__unused__)),
3682
 
                                          MEM_ROOT *parent_alloc __attribute__((__unused__)))
 
3681
                                          bool retrieve_full_rows __attribute__((unused)),
 
3682
                                          MEM_ROOT *parent_alloc __attribute__((unused)))
3683
3683
{
3684
3684
  QUICK_ROR_UNION_SELECT *quick_roru;
3685
3685
  TABLE_READ_PLAN **scan;
4264
4264
get_mm_parts(RANGE_OPT_PARAM *param, COND *cond_func, Field *field,
4265
4265
             Item_func::Functype type,
4266
4266
             Item *value,
4267
 
             Item_result cmp_type __attribute__((__unused__)))
 
4267
             Item_result cmp_type __attribute__((unused)))
4268
4268
{
4269
4269
  if (field->table != param->table)
4270
4270
    return(0);
5925
5925
*/
5926
5926
 
5927
5927
range_seq_t sel_arg_range_seq_init(void *init_param,
5928
 
                                   uint n_ranges __attribute__((__unused__)),
5929
 
                                   uint flags __attribute__((__unused__)))
 
5928
                                   uint n_ranges __attribute__((unused)),
 
5929
                                   uint flags __attribute__((unused)))
5930
5930
{
5931
5931
  SEL_ARG_RANGE_SEQ *seq= (SEL_ARG_RANGE_SEQ*)init_param;
5932
5932
  seq->at_start= true;
7043
7043
*/
7044
7044
 
7045
7045
range_seq_t quick_range_seq_init(void *init_param,
7046
 
                                 uint n_ranges __attribute__((__unused__)),
7047
 
                                 uint flags __attribute__((__unused__)))
 
7046
                                 uint n_ranges __attribute__((unused)),
 
7047
                                 uint flags __attribute__((unused)))
7048
7048
{
7049
7049
  QUICK_RANGE_SELECT *quick= (QUICK_RANGE_SELECT*)init_param;
7050
7050
  quick->qr_traversal_ctx.first=  (QUICK_RANGE**)quick->ranges.buffer;
7152
7152
    Reference to range-associated data
7153
7153
*/
7154
7154
 
7155
 
char* &mrr_get_ptr_by_idx(range_seq_t seq __attribute__((__unused__)),
7156
 
                          uint idx __attribute__((__unused__)))
 
7155
char* &mrr_get_ptr_by_idx(range_seq_t seq __attribute__((unused)),
 
7156
                          uint idx __attribute__((unused)))
7157
7157
{
7158
7158
  static char *dummy;
7159
7159
  return dummy;
7334
7334
 */
7335
7335
 
7336
7336
QUICK_SELECT_DESC::QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q,
7337
 
                                     uint used_key_parts_arg __attribute__((__unused__)),
7338
 
                                     bool *create_err __attribute__((__unused__)))
 
7337
                                     uint used_key_parts_arg __attribute__((unused)),
 
7338
                                     bool *create_err __attribute__((unused)))
7339
7339
 :QUICK_RANGE_SELECT(*q), rev_it(rev_ranges)
7340
7340
{
7341
7341
  QUICK_RANGE *r;
8395
8395
*/
8396
8396
 
8397
8397
static bool
8398
 
get_constant_key_infix(KEY *index_info __attribute__((__unused__)),
 
8398
get_constant_key_infix(KEY *index_info __attribute__((unused)),
8399
8399
                       SEL_ARG *index_range_tree,
8400
8400
                       KEY_PART_INFO *first_non_group_part,
8401
8401
                       KEY_PART_INFO *min_max_arg_part,
8402
8402
                       KEY_PART_INFO *last_part,
8403
 
                       THD *thd __attribute__((__unused__)),
 
8403
                       THD *thd __attribute__((unused)),
8404
8404
                       uchar *key_infix, uint *key_infix_len,
8405
8405
                       KEY_PART_INFO **first_non_infix_part)
8406
8406
{
8594
8594
 
8595
8595
void cost_group_min_max(TABLE* table, KEY *index_info, uint used_key_parts,
8596
8596
                        uint group_key_parts, SEL_TREE *range_tree,
8597
 
                        SEL_ARG *index_tree __attribute__((__unused__)),
 
8597
                        SEL_ARG *index_tree __attribute__((unused)),
8598
8598
                        ha_rows quick_prefix_records,
8599
8599
                        bool have_min, bool have_max,
8600
8600
                        double *read_cost, ha_rows *records)
8691
8691
 
8692
8692
QUICK_SELECT_I *
8693
8693
TRP_GROUP_MIN_MAX::make_quick(PARAM *param,
8694
 
                              bool retrieve_full_rows __attribute__((__unused__)),
 
8694
                              bool retrieve_full_rows __attribute__((unused)),
8695
8695
                              MEM_ROOT *parent_alloc)
8696
8696
{
8697
8697
  QUICK_GROUP_MIN_MAX_SELECT *quick;
9742
9742
}
9743
9743
 
9744
9744
static void print_sel_tree(PARAM *param, SEL_TREE *tree, key_map *tree_map,
9745
 
                           const char *msg __attribute__((__unused__)))
 
9745
                           const char *msg __attribute__((unused)))
9746
9746
{
9747
9747
  SEL_ARG **key,**end;
9748
9748
  int idx;
9770
9770
 
9771
9771
 
9772
9772
static void print_ror_scans_arr(TABLE *table,
9773
 
                                const char *msg __attribute__((__unused__)),
 
9773
                                const char *msg __attribute__((unused)),
9774
9774
                                struct st_ror_scan_info **start,
9775
9775
                                struct st_ror_scan_info **end)
9776
9776
{