← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to sql/opt_range.cc

  • Committer: Monty Taylor
  • Date: 2008-07-09 16:33:52 UTC
  • mto: (77.6.1 glibclient-merge)
  • mto: This revision was merged to the branch mainline in revision 112.
  • Revision ID: monty@inaugust.com-20080709163352-yv7jbu81frc1l4ec
Finished the warnings work!

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/opt_range.cc
1913
1913
  /* Table read plans are allocated on MEM_ROOT and are never deleted */
1914
1914
  static void *operator new(size_t size, MEM_ROOT *mem_root)
1915
1915
  { return (void*) alloc_root(mem_root, (uint) size); }
1916
 
  static void operator delete(void *ptr,size_t size) { TRASH(ptr, size); }
1917
 
  static void operator delete(void *ptr, MEM_ROOT *mem_root) { /* Never called */ }
 
1916
  static void operator delete(void *ptr __attribute__((__unused__)),
 
1917
                              size_t size __attribute__((__unused__)))
 
1918
    { TRASH(ptr, size); }
 
1919
  static void operator delete(void *ptr __attribute__((__unused__)),
 
1920
                              MEM_ROOT *mem_root __attribute__((__unused__)))
 
1921
    { /* Never called */ }
1918
1922
  virtual ~TABLE_READ_PLAN() {}               /* Remove gcc warning */
1919
1923
 
1920
1924
};
1944
1948
  {}
1945
1949
  virtual ~TRP_RANGE() {}                     /* Remove gcc warning */
1946
1950
 
1947
 
  QUICK_SELECT_I *make_quick(PARAM *param, bool retrieve_full_rows,
 
1951
  QUICK_SELECT_I *make_quick(PARAM *param,
 
1952
                             bool retrieve_full_rows __attribute__((__unused__)),
1948
1953
                             MEM_ROOT *parent_alloc)
1949
1954
  {
1950
1955
    DBUG_ENTER("TRP_RANGE::make_quick");
3691
3696
 
3692
3697
 
3693
3698
QUICK_SELECT_I *TRP_INDEX_MERGE::make_quick(PARAM *param,
3694
 
                                            bool retrieve_full_rows,
3695
 
                                            MEM_ROOT *parent_alloc)
 
3699
                                            bool retrieve_full_rows __attribute__((__unused__)),
 
3700
                                            MEM_ROOT *parent_alloc __attribute__((__unused__)))
3696
3701
{
3697
3702
  QUICK_INDEX_MERGE_SELECT *quick_imerge;
3698
3703
  QUICK_RANGE_SELECT *quick;
3769
3774
 
3770
3775
 
3771
3776
QUICK_SELECT_I *TRP_ROR_UNION::make_quick(PARAM *param,
3772
 
                                          bool retrieve_full_rows,
3773
 
                                          MEM_ROOT *parent_alloc)
 
3777
                                          bool retrieve_full_rows __attribute__((__unused__)),
 
3778
                                          MEM_ROOT *parent_alloc __attribute__((__unused__)))
3774
3779
{
3775
3780
  QUICK_ROR_UNION_SELECT *quick_roru;
3776
3781
  TABLE_READ_PLAN **scan;
4358
4363
static SEL_TREE *
4359
4364
get_mm_parts(RANGE_OPT_PARAM *param, COND *cond_func, Field *field,
4360
4365
             Item_func::Functype type,
4361
 
             Item *value, Item_result cmp_type)
 
4366
             Item *value,
 
4367
             Item_result cmp_type __attribute__((__unused__)))
4362
4368
{
4363
4369
  DBUG_ENTER("get_mm_parts");
4364
4370
  if (field->table != param->table)
6024
6030
    Value of init_param
6025
6031
*/
6026
6032
 
6027
 
range_seq_t sel_arg_range_seq_init(void *init_param, uint n_ranges, uint flags)
 
6033
range_seq_t sel_arg_range_seq_init(void *init_param,
 
6034
                                   uint n_ranges __attribute__((__unused__)),
 
6035
                                   uint flags __attribute__((__unused__)))
6028
6036
{
6029
6037
  SEL_ARG_RANGE_SEQ *seq= (SEL_ARG_RANGE_SEQ*)init_param;
6030
6038
  seq->at_start= true;
7149
7157
    Opaque value to be passed to quick_range_seq_next
7150
7158
*/
7151
7159
 
7152
 
range_seq_t quick_range_seq_init(void *init_param, uint n_ranges, uint flags)
 
7160
range_seq_t quick_range_seq_init(void *init_param,
 
7161
                                 uint n_ranges __attribute__((__unused__)),
 
7162
                                 uint flags __attribute__((__unused__)))
7153
7163
{
7154
7164
  QUICK_RANGE_SELECT *quick= (QUICK_RANGE_SELECT*)init_param;
7155
7165
  quick->qr_traversal_ctx.first=  (QUICK_RANGE**)quick->ranges.buffer;
7156
7166
  quick->qr_traversal_ctx.cur=    (QUICK_RANGE**)quick->ranges.buffer;
7157
 
  quick->qr_traversal_ctx.last=   quick->qr_traversal_ctx.cur + 
 
7167
  quick->qr_traversal_ctx.last=   quick->qr_traversal_ctx.cur +
7158
7168
                                  quick->ranges.elements;
7159
7169
  return &quick->qr_traversal_ctx;
7160
7170
}
7257
7267
    Reference to range-associated data
7258
7268
*/
7259
7269
 
7260
 
char* &mrr_get_ptr_by_idx(range_seq_t seq, uint idx)
 
7270
char* &mrr_get_ptr_by_idx(range_seq_t seq __attribute__((__unused__)),
 
7271
                          uint idx __attribute__((__unused__)))
7261
7272
{
7262
7273
  static char *dummy;
7263
7274
  return dummy;
7441
7452
 */
7442
7453
 
7443
7454
QUICK_SELECT_DESC::QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q,
7444
 
                                     uint used_key_parts_arg,
7445
 
                                     bool *create_err)
 
7455
                                     uint used_key_parts_arg __attribute__((__unused__)),
 
7456
                                     bool *create_err __attribute__((__unused__)))
7446
7457
 :QUICK_RANGE_SELECT(*q), rev_it(rev_ranges)
7447
7458
{
7448
7459
  QUICK_RANGE *r;
8513
8524
*/
8514
8525
 
8515
8526
static bool
8516
 
get_constant_key_infix(KEY *index_info, SEL_ARG *index_range_tree,
 
8527
get_constant_key_infix(KEY *index_info __attribute__((__unused__)),
 
8528
                       SEL_ARG *index_range_tree,
8517
8529
                       KEY_PART_INFO *first_non_group_part,
8518
8530
                       KEY_PART_INFO *min_max_arg_part,
8519
 
                       KEY_PART_INFO *last_part, THD *thd,
 
8531
                       KEY_PART_INFO *last_part,
 
8532
                       THD *thd __attribute__((__unused__)),
8520
8533
                       uchar *key_infix, uint *key_infix_len,
8521
8534
                       KEY_PART_INFO **first_non_infix_part)
8522
8535
{
8710
8723
 
8711
8724
void cost_group_min_max(TABLE* table, KEY *index_info, uint used_key_parts,
8712
8725
                        uint group_key_parts, SEL_TREE *range_tree,
8713
 
                        SEL_ARG *index_tree, ha_rows quick_prefix_records,
 
8726
                        SEL_ARG *index_tree __attribute__((__unused__)),
 
8727
                        ha_rows quick_prefix_records,
8714
8728
                        bool have_min, bool have_max,
8715
8729
                        double *read_cost, ha_rows *records)
8716
8730
{
8811
8825
*/
8812
8826
 
8813
8827
QUICK_SELECT_I *
8814
 
TRP_GROUP_MIN_MAX::make_quick(PARAM *param, bool retrieve_full_rows,
 
8828
TRP_GROUP_MIN_MAX::make_quick(PARAM *param,
 
8829
                              bool retrieve_full_rows __attribute__((__unused__)),
8815
8830
                              MEM_ROOT *parent_alloc)
8816
8831
{
8817
8832
  QUICK_GROUP_MIN_MAX_SELECT *quick;