← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/opt_range.cc

  • Committer: Brian Aker
  • Date: 2008-12-05 07:33:29 UTC
  • Revision ID: brian@tangent.org-20081205073329-5f0ejzseqs3ioaq5
Yet more unused.... damn annoying... (also tossed some prototypes that were
missing functions)

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/opt_range.cc
1909
1909
  /* Table read plans are allocated on MEM_ROOT and are never deleted */
1910
1910
  static void *operator new(size_t size, MEM_ROOT *mem_root)
1911
1911
  { return (void*) alloc_root(mem_root, (uint) size); }
1912
 
  static void operator delete(void *ptr __attribute__((unused)),
1913
 
                              size_t size __attribute__((unused)))
 
1912
  static void operator delete(void *, size_t)
1914
1913
    { TRASH(ptr, size); }
1915
 
  static void operator delete(void *ptr __attribute__((unused)),
1916
 
                              MEM_ROOT *mem_root __attribute__((unused)))
 
1914
  static void operator delete(void *, MEM_ROOT *)
1917
1915
    { /* Never called */ }
1918
1916
  virtual ~TABLE_READ_PLAN() {}               /* Remove gcc warning */
1919
1917
 
1944
1942
  {}
1945
1943
  virtual ~TRP_RANGE() {}                     /* Remove gcc warning */
1946
1944
 
1947
 
  QUICK_SELECT_I *make_quick(PARAM *param,
1948
 
                             bool retrieve_full_rows __attribute__((unused)),
1949
 
                             MEM_ROOT *parent_alloc)
 
1945
  QUICK_SELECT_I *make_quick(PARAM *param, bool, MEM_ROOT *parent_alloc)
1950
1946
  {
1951
1947
    QUICK_RANGE_SELECT *quick;
1952
1948
    if ((quick= get_quick_select(param, key_idx, key, mrr_flags, mrr_buf_size,
3623
3619
}
3624
3620
 
3625
3621
 
3626
 
QUICK_SELECT_I *TRP_INDEX_MERGE::make_quick(PARAM *param,
3627
 
                                            bool retrieve_full_rows __attribute__((unused)),
3628
 
                                            MEM_ROOT *parent_alloc __attribute__((unused)))
 
3622
QUICK_SELECT_I *TRP_INDEX_MERGE::make_quick(PARAM *param, bool, MEM_ROOT *)
3629
3623
{
3630
3624
  QUICK_INDEX_MERGE_SELECT *quick_imerge;
3631
3625
  QUICK_RANGE_SELECT *quick;
3700
3694
}
3701
3695
 
3702
3696
 
3703
 
QUICK_SELECT_I *TRP_ROR_UNION::make_quick(PARAM *param,
3704
 
                                          bool retrieve_full_rows __attribute__((unused)),
3705
 
                                          MEM_ROOT *parent_alloc __attribute__((unused)))
 
3697
QUICK_SELECT_I *TRP_ROR_UNION::make_quick(PARAM *param, bool, MEM_ROOT *)
3706
3698
{
3707
3699
  QUICK_ROR_UNION_SELECT *quick_roru;
3708
3700
  TABLE_READ_PLAN **scan;
4286
4278
static SEL_TREE *
4287
4279
get_mm_parts(RANGE_OPT_PARAM *param, COND *cond_func, Field *field,
4288
4280
             Item_func::Functype type,
4289
 
             Item *value,
4290
 
             Item_result cmp_type __attribute__((unused)))
 
4281
             Item *value, Item_result)
4291
4282
{
4292
4283
  if (field->table != param->table)
4293
4284
    return(0);
5952
5943
    Value of init_param
5953
5944
*/
5954
5945
 
5955
 
range_seq_t sel_arg_range_seq_init(void *init_param,
5956
 
                                   uint32_t n_ranges __attribute__((unused)),
5957
 
                                   uint32_t flags __attribute__((unused)))
 
5946
range_seq_t sel_arg_range_seq_init(void *init_param, uint32_t, uint32_t)
5958
5947
{
5959
5948
  SEL_ARG_RANGE_SEQ *seq= (SEL_ARG_RANGE_SEQ*)init_param;
5960
5949
  seq->at_start= true;
7070
7059
    Opaque value to be passed to quick_range_seq_next
7071
7060
*/
7072
7061
 
7073
 
range_seq_t quick_range_seq_init(void *init_param,
7074
 
                                 uint32_t n_ranges __attribute__((unused)),
7075
 
                                 uint32_t flags __attribute__((unused)))
 
7062
range_seq_t quick_range_seq_init(void *init_param, uint32_t, uint32_t)
7076
7063
{
7077
7064
  QUICK_RANGE_SELECT *quick= (QUICK_RANGE_SELECT*)init_param;
7078
7065
  quick->qr_traversal_ctx.first=  (QUICK_RANGE**)quick->ranges.buffer;
7180
7167
    Reference to range-associated data
7181
7168
*/
7182
7169
 
7183
 
char* &mrr_get_ptr_by_idx(range_seq_t seq __attribute__((unused)),
7184
 
                          uint32_t idx __attribute__((unused)))
 
7170
char* &mrr_get_ptr_by_idx(range_seq_t, uint32_t)
7185
7171
{
7186
7172
  static char *dummy;
7187
7173
  return dummy;
7361
7347
  for now, this seems to work right at least.
7362
7348
 */
7363
7349
 
7364
 
QUICK_SELECT_DESC::QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q,
7365
 
                                     uint32_t used_key_parts_arg __attribute__((unused)),
7366
 
                                     bool *create_err __attribute__((unused)))
 
7350
QUICK_SELECT_DESC::QUICK_SELECT_DESC(QUICK_RANGE_SELECT *q, uint32_t, bool *)
7367
7351
 :QUICK_RANGE_SELECT(*q), rev_it(rev_ranges)
7368
7352
{
7369
7353
  QUICK_RANGE *r;
8421
8405
*/
8422
8406
 
8423
8407
static bool
8424
 
get_constant_key_infix(KEY *index_info __attribute__((unused)),
8425
 
                       SEL_ARG *index_range_tree,
 
8408
get_constant_key_infix(KEY *, SEL_ARG *index_range_tree,
8426
8409
                       KEY_PART_INFO *first_non_group_part,
8427
8410
                       KEY_PART_INFO *min_max_arg_part,
8428
8411
                       KEY_PART_INFO *last_part,
8429
 
                       Session *session __attribute__((unused)),
8430
 
                       unsigned char *key_infix, uint32_t *key_infix_len,
 
8412
                       Session *, unsigned char *key_infix, uint32_t *key_infix_len,
8431
8413
                       KEY_PART_INFO **first_non_infix_part)
8432
8414
{
8433
8415
  SEL_ARG       *cur_range;
8620
8602
 
8621
8603
void cost_group_min_max(Table* table, KEY *index_info, uint32_t used_key_parts,
8622
8604
                        uint32_t group_key_parts, SEL_TREE *range_tree,
8623
 
                        SEL_ARG *index_tree __attribute__((unused)),
8624
 
                        ha_rows quick_prefix_records,
 
8605
                        SEL_ARG *, ha_rows quick_prefix_records,
8625
8606
                        bool have_min, bool have_max,
8626
8607
                        double *read_cost, ha_rows *records)
8627
8608
{
8716
8697
*/
8717
8698
 
8718
8699
QUICK_SELECT_I *
8719
 
TRP_GROUP_MIN_MAX::make_quick(PARAM *param,
8720
 
                              bool retrieve_full_rows __attribute__((unused)),
8721
 
                              MEM_ROOT *parent_alloc)
 
8700
TRP_GROUP_MIN_MAX::make_quick(PARAM *param, bool, MEM_ROOT *parent_alloc)
8722
8701
{
8723
8702
  QUICK_GROUP_MIN_MAX_SELECT *quick;
8724
8703
 
9767
9746
  used_lengths->append(buf, length);
9768
9747
}
9769
9748
 
9770
 
static void print_sel_tree(PARAM *param, SEL_TREE *tree, key_map *tree_map,
9771
 
                           const char *msg __attribute__((unused)))
 
9749
static void print_sel_tree(PARAM *param, SEL_TREE *tree, key_map *tree_map, const char *)
9772
9750
{
9773
9751
  SEL_ARG **key,**end;
9774
9752
  int idx;
9796
9774
 
9797
9775
 
9798
9776
static void print_ror_scans_arr(Table *table,
9799
 
                                const char *msg __attribute__((unused)),
9800
 
                                struct st_ror_scan_info **start,
 
9777
                                const char *, struct st_ror_scan_info **start,
9801
9778
                                struct st_ror_scan_info **end)
9802
9779
{
9803
9780
  char buff[1024];