← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/schema_dictionary/columns.cc

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/schema_dictionary/columns.cc
1
1
/* - mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2010 Sun Microsystems
 
4
 *  Copyright (C) 2010 Sun Microsystems, Inc.
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
26
26
 
27
27
 
28
28
ColumnsTool::ColumnsTool() :
29
 
  TablesTool("COLUMNS")
 
29
  DataDictionary("COLUMNS")
30
30
{
31
31
  add_field("TABLE_SCHEMA");
32
32
  add_field("TABLE_NAME");
37
37
  add_field("COLUMN_DEFAULT", plugin::TableFunction::VARBINARY, 65535, true);
38
38
  add_field("COLUMN_DEFAULT_IS_NULL", plugin::TableFunction::BOOLEAN, 0, false);
39
39
  add_field("COLUMN_DEFAULT_UPDATE");
 
40
  add_field("IS_SIGNED", plugin::TableFunction::BOOLEAN, 0, true);
 
41
  add_field("IS_AUTO_INCREMENT", plugin::TableFunction::BOOLEAN, 0, false);
40
42
  add_field("IS_NULLABLE", plugin::TableFunction::BOOLEAN, 0, false);
41
43
  add_field("IS_INDEXED", plugin::TableFunction::BOOLEAN, 0, false);
42
44
  add_field("IS_USED_IN_PRIMARY", plugin::TableFunction::BOOLEAN, 0, false);
45
47
  add_field("IS_FIRST_IN_MULTI", plugin::TableFunction::BOOLEAN, 0, false);
46
48
  add_field("INDEXES_FOUND_IN", plugin::TableFunction::NUMBER, 0, false);
47
49
  add_field("DATA_TYPE");
48
 
 
 
50
  add_field("DATA_ARCHETYPE");
49
51
  add_field("CHARACTER_MAXIMUM_LENGTH", plugin::TableFunction::NUMBER);
50
52
  add_field("CHARACTER_OCTET_LENGTH", plugin::TableFunction::NUMBER);
51
53
  add_field("NUMERIC_PRECISION", plugin::TableFunction::NUMBER);
52
54
  add_field("NUMERIC_SCALE", plugin::TableFunction::NUMBER);
53
55
 
 
56
  add_field("ENUM_VALUES", plugin::TableFunction::STRING, 1024, true);
 
57
 
54
58
  add_field("COLLATION_NAME");
55
59
 
56
60
  add_field("COLUMN_COMMENT", plugin::TableFunction::STRING, 1024, true);
58
62
 
59
63
 
60
64
ColumnsTool::Generator::Generator(Field **arg) :
61
 
  TablesTool::Generator(arg),
62
 
  column_iterator(0),
63
 
  is_columns_primed(false)
64
 
{
65
 
}
66
 
 
67
 
 
68
 
bool ColumnsTool::Generator::nextColumnCore()
69
 
{
70
 
  if (is_columns_primed)
71
 
  {
72
 
    column_iterator++;
73
 
  }
74
 
  else
75
 
  {
76
 
    if (not isTablesPrimed())
77
 
      return false;
78
 
 
79
 
    column_iterator= 0;
80
 
    is_columns_primed= true;
81
 
  }
82
 
 
83
 
  if (column_iterator >= getTableProto().field_size())
84
 
    return false;
85
 
 
86
 
  column= getTableProto().field(column_iterator);
87
 
 
88
 
  return true;
89
 
}
90
 
 
91
 
 
92
 
bool ColumnsTool::Generator::nextColumn()
93
 
{
94
 
  while (not nextColumnCore())
95
 
  {
96
 
    if (not nextTable())
97
 
      return false;
98
 
    is_columns_primed= false;
99
 
  }
100
 
 
101
 
  return true;
 
65
  DataDictionary::Generator(arg),
 
66
  field_generator(getSession())
 
67
{
102
68
}
103
69
 
104
70
bool ColumnsTool::Generator::populate()
105
71
{
106
 
 
107
 
  if (not nextColumn())
108
 
    return false;
109
 
 
110
 
  fill();
111
 
 
112
 
  return true;
113
 
}
114
 
 
115
 
void ColumnsTool::Generator::fill()
116
 
{
117
 
  /* TABLE_SCHEMA */
118
 
  assert(getTableProto().schema().length());
119
 
  assert(getTableProto().schema().c_str());
120
 
  push(getTableProto().schema());
121
 
 
122
 
  /* TABLE_NAME */
123
 
  push(getTableProto().name());
124
 
 
125
 
  /* COLUMN_NAME */
126
 
  push(column.name());
127
 
 
128
 
  /* COLUMN_TYPE */
129
 
  pushType(column.type());
130
 
 
131
 
  /* ORDINAL_POSITION */
132
 
  push(static_cast<int64_t>(column_iterator));
133
 
 
134
 
  /* COLUMN_DEFAULT */
135
 
  if (column.options().has_default_value())
136
 
  {
137
 
    push(column.options().default_value());
138
 
  }
139
 
  else if (column.options().has_default_bin_value())
140
 
  {
141
 
    push(column.options().default_bin_value().c_str(), column.options().default_bin_value().length());
142
 
  }
143
 
  else if (column.options().has_default_expression())
144
 
  {
145
 
    push(column.options().default_expression());
146
 
  }
147
 
  else
148
 
  {
149
 
    push();
150
 
  }
151
 
 
152
 
  /* COLUMN_DEFAULT_IS_NULL */
153
 
  push(column.options().default_null());
154
 
 
155
 
  /* COLUMN_DEFAULT_UPDATE */
156
 
  push(column.options().update_expression());
157
 
 
158
 
  /* IS_NULLABLE */
159
 
  push(column.constraints().is_nullable());
160
 
 
161
 
  /* IS_INDEXED, IS_USED_IN_PRIMARY, IS_UNIQUE, IS_MULTI, IS_FIRST_IN_MULTI, INDEXES_FOUND_IN */
162
 
  bool is_indexed= false;
163
 
  bool is_primary= false;
164
 
  bool is_unique= false;
165
 
  bool is_multi= false;
166
 
  bool is_multi_first= false;
167
 
  int64_t indexes_found_in= 0;
168
 
  for (int32_t x= 0; x < getTableProto().indexes_size() ; x++)
169
 
  {
170
 
    drizzled::message::Table::Index index=
171
 
      getTableProto().indexes(x);
172
 
 
173
 
    for (int32_t y= 0; y < index.index_part_size() ; y++)
174
 
    {
175
 
      drizzled::message::Table::Index::IndexPart index_part=
176
 
        index.index_part(y);
177
 
 
178
 
      if (static_cast<int32_t>(index_part.fieldnr()) == column_iterator)
 
72
  drizzled::generator::FieldPair field_pair;
 
73
 
 
74
  while (!!(field_pair= field_generator))
 
75
  {
 
76
    const drizzled::message::Table *table_message= field_pair.first;
 
77
    int32_t field_iterator= field_pair.second;
 
78
    const message::Table::Field &column(table_message->field(field_pair.second));
 
79
 
 
80
    /* TABLE_SCHEMA */
 
81
    push(table_message->schema());
 
82
 
 
83
    /* TABLE_NAME */
 
84
    push(table_message->name());
 
85
 
 
86
    /* COLUMN_NAME */
 
87
    push(column.name());
 
88
 
 
89
    /* COLUMN_TYPE */
 
90
    push(drizzled::message::type(column.type()));
 
91
 
 
92
    /* ORDINAL_POSITION */
 
93
    push(static_cast<int64_t>(field_iterator));
 
94
 
 
95
    /* COLUMN_DEFAULT */
 
96
    if (column.options().has_default_value())
 
97
    {
 
98
      push(column.options().default_value());
 
99
    }
 
100
    else if (column.options().has_default_bin_value())
 
101
    {
 
102
      push(column.options().default_bin_value().c_str(), column.options().default_bin_value().length());
 
103
    }
 
104
    else if (column.options().has_default_expression())
 
105
    {
 
106
      push(column.options().default_expression());
 
107
    }
 
108
    else
 
109
    {
 
110
      push();
 
111
    }
 
112
 
 
113
    /* COLUMN_DEFAULT_IS_NULL */
 
114
    push(column.options().default_null());
 
115
 
 
116
    /* COLUMN_DEFAULT_UPDATE */
 
117
    push(column.options().update_expression());
 
118
 
 
119
    /* IS_SIGNED */
 
120
    if (drizzled::message::is_numeric(column))
 
121
    {
 
122
      push(true);
 
123
    }
 
124
    else 
 
125
    {
 
126
      push();
 
127
    }
 
128
 
 
129
    /* IS_AUTO_INCREMENT */
 
130
    push(column.numeric_options().is_autoincrement());
 
131
 
 
132
    /* IS_NULLABLE */
 
133
    push(not column.constraints().is_notnull());
 
134
 
 
135
    /* IS_INDEXED, IS_USED_IN_PRIMARY, IS_UNIQUE, IS_MULTI, IS_FIRST_IN_MULTI, INDEXES_FOUND_IN */
 
136
    bool is_indexed= false;
 
137
    bool is_primary= false;
 
138
    bool is_unique= false;
 
139
    bool is_multi= false;
 
140
    bool is_multi_first= false;
 
141
    int64_t indexes_found_in= 0;
 
142
    for (int32_t x= 0; x < table_message->indexes_size() ; x++)
 
143
    {
 
144
      const drizzled::message::Table::Index &index(table_message->indexes(x));
 
145
 
 
146
      for (int32_t y= 0; y < index.index_part_size() ; y++)
179
147
      {
180
 
        indexes_found_in++;
181
 
        is_indexed= true;
182
 
 
183
 
        if (index.is_primary())
184
 
          is_primary= true;
185
 
 
186
 
        if (index.is_unique())
187
 
          is_unique= true;
188
 
 
189
 
        if (index.index_part_size() > 1)
 
148
        const drizzled::message::Table::Index::IndexPart &index_part(index.index_part(y));
 
149
 
 
150
        if (static_cast<int32_t>(index_part.fieldnr()) == field_iterator)
190
151
        {
191
 
          is_multi= true;
192
 
 
193
 
          if (y == 0)
194
 
            is_multi_first= true;
 
152
          indexes_found_in++;
 
153
          is_indexed= true;
 
154
 
 
155
          if (index.is_primary())
 
156
            is_primary= true;
 
157
 
 
158
          if (index.is_unique())
 
159
            is_unique= true;
 
160
 
 
161
          if (index.index_part_size() > 1)
 
162
          {
 
163
            is_multi= true;
 
164
 
 
165
            if (y == 0)
 
166
              is_multi_first= true;
 
167
          }
195
168
        }
196
169
      }
197
170
    }
198
 
  }
199
 
  /* ...IS_INDEXED, IS_USED_IN_PRIMARY, IS_UNIQUE, IS_MULTI, IS_FIRST_IN_MULTI, INDEXES_FOUND_IN */
200
 
  push(is_indexed);
201
 
  push(is_primary);
202
 
  push(is_unique);
203
 
  push(is_multi);
204
 
  push(is_multi_first);
205
 
  push(indexes_found_in);
206
 
 
207
 
  /* DATATYPE */
208
 
  pushType(column.type());
209
 
 
210
 
 /* "CHARACTER_MAXIMUM_LENGTH" */
211
 
  push(static_cast<int64_t>(column.string_options().length()));
212
 
 
213
 
 /* "CHARACTER_OCTET_LENGTH" */
214
 
  push(static_cast<int64_t>(column.string_options().length()) * 4);
215
 
 
216
 
 /* "NUMERIC_PRECISION" */
217
 
  push(static_cast<int64_t>(column.numeric_options().precision()));
218
 
 
219
 
 /* "NUMERIC_SCALE" */
220
 
  push(static_cast<int64_t>(column.numeric_options().scale()));
221
 
 
222
 
 /* "COLLATION_NAME" */
223
 
  push(column.string_options().collation());
224
 
 
225
 
 /* "COLUMN_COMMENT" */
226
 
  if (column.has_comment())
227
 
  {
228
 
    push(column.comment());
229
 
  }
230
 
  else
231
 
  {
232
 
    push();
233
 
  }
 
171
    /* ...IS_INDEXED, IS_USED_IN_PRIMARY, IS_UNIQUE, IS_MULTI, IS_FIRST_IN_MULTI, INDEXES_FOUND_IN */
 
172
    push(is_indexed);
 
173
    push(is_primary);
 
174
    push(is_unique);
 
175
    push(is_multi);
 
176
    push(is_multi_first);
 
177
    push(indexes_found_in);
 
178
 
 
179
    /* DATA_TYPE <-- display the type that the user is going to expect, which is not the same as the type we store internally */
 
180
    push(drizzled::message::type(column));
 
181
 
 
182
    /* DATA_ARCHETYPE */
 
183
    push(drizzled::message::type(column.type()));
 
184
 
 
185
    /* "CHARACTER_MAXIMUM_LENGTH" */
 
186
    push(static_cast<int64_t>(column.string_options().length()));
 
187
 
 
188
    /* "CHARACTER_OCTET_LENGTH" */
 
189
    push(static_cast<int64_t>(column.string_options().length()) * 4);
 
190
 
 
191
    /* "NUMERIC_PRECISION" */
 
192
    push(static_cast<int64_t>(column.numeric_options().precision()));
 
193
 
 
194
    /* "NUMERIC_SCALE" */
 
195
    push(static_cast<int64_t>(column.numeric_options().scale()));
 
196
 
 
197
    /* "ENUM_VALUES" */
 
198
    if (column.type() == drizzled::message::Table::Field::ENUM)
 
199
    {
 
200
      string destination;
 
201
      size_t num_field_values= column.enumeration_values().field_value_size();
 
202
      for (size_t x= 0; x < num_field_values; ++x)
 
203
      {
 
204
        const string &type= column.enumeration_values().field_value(x);
 
205
 
 
206
        if (x != 0)
 
207
          destination.push_back(',');
 
208
 
 
209
        destination.push_back('\'');
 
210
        destination.append(type);
 
211
        destination.push_back('\'');
 
212
      }
 
213
      push(destination);
 
214
    }
 
215
    else
 
216
    {
 
217
      push();
 
218
    }
 
219
 
 
220
    /* "COLLATION_NAME" */
 
221
    push(column.string_options().collation());
 
222
 
 
223
    /* "COLUMN_COMMENT" */
 
224
    if (column.has_comment())
 
225
    {
 
226
      push(column.comment());
 
227
    }
 
228
    else
 
229
    {
 
230
      push();
 
231
    }
 
232
 
 
233
    return true;
 
234
  }
 
235
 
 
236
  return false;
234
237
}