← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/item/ident.cc

  • Committer: Mark Atwood
  • Date: 2011-08-12 04:08:33 UTC
  • mfrom: (2385.2.17 refactor5)
  • Revision ID: me@mark.atwood.name-20110812040833-u6j85nc6ahuc0dtz
merge lp:~olafvdspek/drizzle/refactor5

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/item/ident.cc
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#include "config.h"
 
20
#include <config.h>
21
21
#include <drizzled/show.h>
22
22
#include <drizzled/table.h>
23
23
#include <drizzled/item/ident.h>
26
26
 
27
27
using namespace std;
28
28
 
29
 
namespace drizzled
30
 
{
 
29
namespace drizzled {
31
30
 
32
31
const uint32_t NO_CACHED_FIELD_INDEX= UINT32_MAX;
33
32
 
41
40
   alias_name_used(false), cached_field_index(NO_CACHED_FIELD_INDEX),
42
41
   cached_table(0), depended_from(0)
43
42
{
44
 
  name = (char*) field_name_arg;
 
43
  name = field_name_arg;
45
44
}
46
45
 
47
46
/**
70
69
  table_name= orig_table_name;
71
70
  field_name= orig_field_name;
72
71
  depended_from= 0;
73
 
  return;
74
72
}
75
73
 
76
74
bool Item_ident::remove_dependence_processor(unsigned char * arg)
77
75
{
78
76
  if (depended_from == (Select_Lex *) arg)
79
77
    depended_from= 0;
80
 
  return(0);
 
78
  return 0;
81
79
}
82
80
 
83
81
const char *Item_ident::full_name() const
84
82
{
85
 
  char *tmp;
86
 
        size_t tmp_len;
87
83
  if (!table_name || !field_name)
88
84
    return field_name ? field_name : name ? name : "tmp_field";
89
85
  if (db_name && db_name[0])
90
86
  {
91
 
    tmp_len= strlen(db_name)+strlen(table_name)+strlen(field_name)+3;
92
 
    tmp= (char*) memory::sql_alloc(tmp_len);
 
87
    size_t tmp_len= strlen(db_name)+strlen(table_name)+strlen(field_name)+3;
 
88
    char* tmp= (char*) memory::sql_alloc(tmp_len);
93
89
    snprintf(tmp, tmp_len, "%s.%s.%s",db_name,table_name,field_name);
 
90
    return tmp;
94
91
  }
95
 
  else
 
92
  if (table_name[0])
96
93
  {
97
 
    if (table_name[0])
98
 
    {
99
 
      tmp_len=strlen(table_name)+strlen(field_name)+2;
100
 
      tmp= (char*) memory::sql_alloc(tmp_len);
101
 
      snprintf(tmp, tmp_len, "%s.%s", table_name, field_name);
102
 
    }
103
 
    else
104
 
      tmp= (char*) field_name;
 
94
    size_t tmp_len= strlen(table_name)+strlen(field_name)+2;
 
95
    char* tmp= (char*) memory::sql_alloc(tmp_len);
 
96
    snprintf(tmp, tmp_len, "%s.%s", table_name, field_name);
 
97
    return tmp;
105
98
  }
106
 
  return tmp;
 
99
  return field_name;
107
100
}
108
101
 
109
102
 
110
 
void Item_ident::print(String *str,
111
 
                       enum_query_type)
 
103
void Item_ident::print(String *str)
112
104
{
113
105
  string d_name, t_name;
114
106
 
115
107
  if (table_name && table_name[0])
116
108
  {
117
 
    t_name.assign(table_name);
118
 
    std::transform(t_name.begin(), t_name.end(),
119
 
                   t_name.begin(), ::tolower);
 
109
    t_name= table_name;
 
110
    boost::to_lower(t_name);
120
111
  }
121
112
 
122
113
  if (db_name && db_name[0])
123
114
  {
124
 
    d_name.assign(db_name);
125
 
    // Keeping the std:: prefix here, since Item_ident has a transform
126
 
    // method
127
 
      std::transform(d_name.begin(), d_name.end(),
128
 
                     d_name.begin(), ::tolower);
 
115
    d_name= db_name;
 
116
    boost::to_lower(d_name);
129
117
  }
130
118
 
131
119
  if (!table_name || !field_name || !field_name[0])
132
120
  {
133
 
    const char *nm= (field_name && field_name[0]) ?
134
 
                      field_name : name ? name : "tmp_field";
135
 
    str->append_identifier(nm, (uint32_t) strlen(nm));
136
 
 
 
121
    str->append_identifier(str_ref((field_name && field_name[0]) ? field_name : name ? name : "tmp_field"));
137
122
    return;
138
123
  }
139
124
  if (db_name && db_name[0] && !alias_name_used)
140
125
  {
141
 
    {
142
 
      str->append_identifier(d_name.c_str(), d_name.length());
143
 
      str->append('.');
144
 
    }
145
 
    str->append_identifier(t_name.c_str(), t_name.length());
146
 
    str->append('.');
147
 
    str->append_identifier(field_name, (uint32_t)strlen(field_name));
 
126
    str->append_identifier(d_name);
 
127
    str->append('.');
 
128
    str->append_identifier(t_name);
 
129
    str->append('.');
 
130
    str->append_identifier(str_ref(field_name));
148
131
  }
149
132
  else
150
133
  {
151
134
    if (table_name[0])
152
135
    {
153
 
      str->append_identifier(t_name.c_str(), t_name.length());
 
136
      str->append_identifier(t_name);
154
137
      str->append('.');
155
 
      str->append_identifier(field_name, (uint32_t) strlen(field_name));
 
138
      str->append_identifier(str_ref(field_name));
156
139
    }
157
140
    else
158
 
      str->append_identifier(field_name, (uint32_t) strlen(field_name));
 
141
      str->append_identifier(str_ref(field_name));
159
142
  }
160
143
}
161
144
 
190
173
  tmp_field->charsetnr= field->charset()->number;
191
174
  tmp_field->length=field->field_length;
192
175
  tmp_field->type=field->type();
193
 
  tmp_field->flags= field->getTable()->maybe_null ?
194
 
    (field->flags & ~NOT_NULL_FLAG) : field->flags;
 
176
  tmp_field->flags= field->getTable()->maybe_null ? (field->flags & ~NOT_NULL_FLAG) : field->flags;
195
177
  tmp_field->decimals= field->decimals();
196
178
}
197
179