← Back to branch summary

~ubuntu-branches/ubuntu/precise/mysql-5.1/precise

« back to all changes in this revision

Viewing changes to sql/sql_olap.cc

  • Committer: Bazaar Package Importer
  • Author(s): Norbert Tretkowski
  • Date: 2010-03-17 14:56:02 UTC
  • Revision ID: james.westby@ubuntu.com-20100317145602-x7e30l1b2sb5s6w6
Tags: upstream-5.1.45
Import upstream version 5.1.45

Show diffs side-by-side

added added

removed removed

Lines of Context:
sql/sql_olap.cc
 
1
/* Copyright (C) 2000-2006 MySQL AB
 
2
 
 
3
   This program is free software; you can redistribute it and/or modify
 
4
   it under the terms of the GNU General Public License as published by
 
5
   the Free Software Foundation; version 2 of the License.
 
6
 
 
7
   This program is distributed in the hope that it will be useful,
 
8
   but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
   GNU General Public License for more details.
 
11
 
 
12
   You should have received a copy of the GNU General Public License
 
13
   along with this program; if not, write to the Free Software
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
 
 
17
/*
 
18
  OLAP implementation by Sinisa Milivojevic <sinisa@mysql.com>
 
19
  Inspired by code submitted by Srilakshmi <lakshmi@gdit.iiit.net>
 
20
 
 
21
  The ROLLUP code in this file has to be complitely rewritten as it's
 
22
  not good enough to satisfy the goals of MySQL.
 
23
 
 
24
  In 4.1 we will replace this with a working, superior implementation
 
25
  of ROLLUP.
 
26
*/
 
27
 
 
28
#ifdef DISABLED_UNTIL_REWRITTEN_IN_4_1
 
29
 
 
30
#ifdef USE_PRAGMA_IMPLEMENTATION
 
31
#pragma implementation                          // gcc: Class implementation
 
32
#endif
 
33
 
 
34
#include "mysql_priv.h"
 
35
#include "sql_select.h"
 
36
 
 
37
 
 
38
/****************************************************************************
 
39
  Functions that recursively actually creates new SELECT's
 
40
  Returns 0 if OK, 1 if error, -1 if error already printed to client
 
41
****************************************************************************/
 
42
 
 
43
 
 
44
static int make_new_olap_select(LEX *lex, SELECT_LEX *select_lex, List<Item> new_fields)
 
45
{
 
46
  THD   *thd=current_thd;
 
47
  Item *item, *new_item;
 
48
  Item_null *constant= new Item_null("ALL");
 
49
 
 
50
  SELECT_LEX *new_select = (SELECT_LEX *) thd->memdup((char*) select_lex, sizeof(*select_lex));
 
51
  if (!new_select)
 
52
    return 1;
 
53
  lex->last_selects->next=new_select;
 
54
  new_select->linkage=OLAP_TYPE;
 
55
  new_select->olap=NON_EXISTING_ONE;
 
56
  new_select->group_list.elements=0;
 
57
  new_select->group_list.first=(uchar *)0;
 
58
  new_select->group_list.next=(uchar **)&new_select->group_list.first;
 
59
  List<Item> privlist;
 
60
  
 
61
  List_iterator<Item> list_it(select_lex->item_list);
 
62
  List_iterator<Item> new_it(new_fields);
 
63
    
 
64
  while ((item=list_it++))
 
65
  {
 
66
    bool not_found= TRUE;
 
67
    if (item->type()==Item::FIELD_ITEM)
 
68
    {
 
69
      Item_field *iif = (Item_field *)item;
 
70
      new_it.rewind();
 
71
      while ((new_item=new_it++))
 
72
      {
 
73
        if (new_item->type()==Item::FIELD_ITEM && 
 
74
            !strcmp(((Item_field*)new_item)->table_name,iif->table_name) &&
 
75
            !strcmp(((Item_field*)new_item)->field_name,iif->field_name))
 
76
        {
 
77
          not_found= 0;
 
78
          ((Item_field*)new_item)->db_name=iif->db_name;
 
79
          Item_field *new_one=new Item_field(&select_lex->context,
 
80
                                             iif->db_name, iif->table_name, iif->field_name);
 
81
          privlist.push_back(new_one);
 
82
          if (add_to_list(new_select->group_list,new_one,1))
 
83
            return 1;
 
84
          break;
 
85
        }
 
86
      }
 
87
    }
 
88
    if (not_found)
 
89
    {
 
90
      if (item->type() == Item::FIELD_ITEM)
 
91
        privlist.push_back(constant);
 
92
      else
 
93
        privlist.push_back((Item*)thd->memdup((char *)item,item->size_of()));
 
94
    }
 
95
  }
 
96
  new_select->item_list=privlist;
 
97
 
 
98
  lex->last_selects = new_select;
 
99
  return 0;
 
100
}
 
101
 
 
102
/****************************************************************************
 
103
  Functions that recursively creates combinations of queries for OLAP
 
104
  Returns 0 if OK, 1 if error, -1 if error already printed to client
 
105
****************************************************************************/
 
106
 
 
107
static int  olap_combos(List<Item> old_fields, List<Item> new_fields, Item *item, LEX *lex, 
 
108
                              SELECT_LEX *select_lex, int position, int selection, int num_fields, 
 
109
                              int num_new_fields)
 
110
{
 
111
  int sl_return = 0;
 
112
  if (position == num_new_fields)
 
113
  {
 
114
    if (item)
 
115
      new_fields.push_front(item);
 
116
    sl_return = make_new_olap_select(lex, select_lex, new_fields);
 
117
  }
 
118
  else
 
119
  {
 
120
    if (item)
 
121
      new_fields.push_front(item);
 
122
    while ((num_fields - num_new_fields >= selection - position) && !sl_return)
 
123
    {
 
124
      item = old_fields.pop();
 
125
      sl_return = olap_combos(old_fields, new_fields, item, lex, select_lex, position+1, ++selection, num_fields, num_new_fields);
 
126
    }
 
127
  }
 
128
  return sl_return;
 
129
}
 
130
 
 
131
 
 
132
/****************************************************************************
 
133
  Top level function for converting OLAP clauses to multiple selects
 
134
  This is also a place where clauses treatment depends on OLAP type 
 
135
  Returns 0 if OK, 1 if error, -1 if error already printed to client
 
136
****************************************************************************/
 
137
 
 
138
int handle_olaps(LEX *lex, SELECT_LEX *select_lex)
 
139
{
 
140
  List<Item> item_list_copy, new_item_list;
 
141
  item_list_copy.empty();
 
142
  new_item_list.empty();
 
143
  int count=select_lex->group_list.elements;
 
144
  int sl_return=0;
 
145
 
 
146
 
 
147
  lex->last_selects=select_lex;
 
148
 
 
149
  for (ORDER *order=(ORDER *)select_lex->group_list.first ; order ; order=order->next)
 
150
    item_list_copy.push_back(*(order->item));
 
151
 
 
152
  List<Item>    all_fields(select_lex->item_list);
 
153
 
 
154
 
 
155
  if (setup_tables(lex->thd, &select_lex->context, &select_lex->top_join_list,
 
156
                   (TABLE_LIST *)select_lex->table_list.first
 
157
                   &select_lex->leaf_tables, FALSE) ||
 
158
      setup_fields(lex->thd, 0, select_lex->item_list, MARK_COLUMNS_READ,
 
159
                   &all_fields,1) ||
 
160
      setup_fields(lex->thd, 0, item_list_copy, MARK_COLUMNS_READ,
 
161
                   &all_fields, 1))
 
162
    return -1;
 
163
 
 
164
  if (select_lex->olap == CUBE_TYPE)
 
165
  {
 
166
    for ( int i=count-1; i>=0 && !sl_return; i--)
 
167
      sl_return=olap_combos(item_list_copy, new_item_list, (Item *)0, lex, select_lex, 0, 0, count, i);
 
168
  }
 
169
  else if (select_lex->olap == ROLLUP_TYPE)
 
170
  {
 
171
    for ( int i=count-1; i>=0 && !sl_return; i--)
 
172
    {
 
173
      Item *item;
 
174
      item_list_copy.pop();
 
175
      List_iterator<Item> it(item_list_copy);
 
176
      new_item_list.empty();
 
177
      while ((item = it++))
 
178
        new_item_list.push_front(item);
 
179
      sl_return=make_new_olap_select(lex, select_lex, new_item_list);
 
180
    }
 
181
  }
 
182
  else
 
183
    sl_return=1; // impossible
 
184
  return sl_return;
 
185
}
 
186
 
 
187
#endif /* DISABLED_UNTIL_REWRITTEN_IN_4_1 */