← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/serialize/table_reader.cc

  • Committer: Monty Taylor
  • Date: 2008-08-21 03:34:05 UTC
  • mfrom: (352.1.2 proto-definitions)
  • Revision ID: monty@inaugust.com-20080821033405-299aw5nxk7cpj6de
Merged from Jay.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/serialize/table_reader.cc
8
8
  Written from Google proto example
9
9
*/
10
10
 
11
 
void printType(const drizzle::Table::Field *field) 
 
11
void print_field(const drizzle::Table::Field *field) 
12
12
{
 
13
  using namespace drizzle;
 
14
  cout << "\t`" << field->name() << "`";
13
15
  switch (field->type())
14
16
  {
15
 
  case drizzle::Table::DOUBLE:
 
17
    case Table::Field::DOUBLE:
16
18
    cout << " DOUBLE ";
17
19
    break;
18
 
  case drizzle::Table::VARCHAR:
19
 
    cout << " VARCHAR(" << field->length() << ")";
 
20
  case Table::Field::VARCHAR:
 
21
    cout << " VARCHAR(" << field->string_options().length() << ")";
20
22
    break;
21
 
  case drizzle::Table::TEXT:
 
23
  case Table::Field::TEXT:
22
24
    cout << " TEXT ";
23
25
    break;
24
 
  case drizzle::Table::BLOB:
 
26
  case Table::Field::BLOB:
25
27
    cout << " BLOB ";
26
28
    break;
27
 
  case drizzle::Table::ENUM:
 
29
  case Table::Field::ENUM:
28
30
    {
29
31
      int x;
30
32
 
31
33
      cout << " ENUM(";
32
 
      for (x= 0; x < field->values_size() ; x++)
 
34
      for (x= 0; x < field->set_options().value_size() ; x++)
33
35
      {
34
 
        const string type= field->values(x);
 
36
        const string type= field->set_options().value(x);
35
37
 
36
38
        if (x != 0)
37
39
          cout << ",";
40
42
      cout << ") ";
41
43
      break;
42
44
    }
43
 
  case drizzle::Table::SET:
 
45
  case Table::Field::SET:
44
46
    cout << " SET ";
45
47
    break;
46
 
  case drizzle::Table::TINYINT:
47
 
    cout << " TINYINNT ";
 
48
  case Table::Field::TINYINT:
 
49
    cout << " TINYINT ";
48
50
    break;
49
 
  case drizzle::Table::SMALLINT:
 
51
  case Table::Field::SMALLINT:
50
52
    cout << " SMALLINT ";
51
53
    break;
52
 
  case drizzle::Table::INTEGER:
 
54
  case Table::Field::INTEGER:
53
55
    cout << " INTEGER ";
54
56
    break;
55
 
  case drizzle::Table::BIGINT:
 
57
  case Table::Field::BIGINT:
56
58
    cout << " BIGINT ";
57
59
    break;
58
 
  case drizzle::Table::DECIMAL:
59
 
    cout << " DECIMAL(" << field->length() << "," << field->scale() << ") ";
60
 
    break;
61
 
  case drizzle::Table::VARBINARY:
62
 
    cout << " VARBINARY(" << field->length() << ") ";
63
 
    break;
64
 
  case drizzle::Table::DATE:
 
60
  case Table::Field::DECIMAL:
 
61
    cout << " DECIMAL(" << field->numeric_options().precision() << "," << field->numeric_options().scale() << ") ";
 
62
    break;
 
63
  case Table::Field::VARBINARY:
 
64
    cout << " VARBINARY(" << field->string_options().length() << ") ";
 
65
    break;
 
66
  case Table::Field::DATE:
65
67
    cout << " DATE ";
66
68
    break;
67
 
  case drizzle::Table::TIME:
 
69
  case Table::Field::TIME:
68
70
    cout << " TIME ";
69
71
    break;
70
 
  case drizzle::Table::TIMESTAMP:
 
72
  case Table::Field::TIMESTAMP:
71
73
    cout << " TIMESTAMP ";
72
74
    break;
73
 
  case drizzle::Table::DATETIME:
 
75
  case Table::Field::DATETIME:
74
76
    cout << " DATETIME ";
75
77
    break;
76
78
  }
77
79
 
78
 
  if (field->has_characterset())
79
 
    cout << " CHARACTER SET " << field->characterset();
80
 
 
81
 
  if (field->has_collation())
82
 
    cout << " COLLATE " << field->collation();
83
 
 
84
 
  if (field->is_notnull())
 
80
  if (field->type() == Table::Field::INTEGER
 
81
      || field->type() == Table::Field::BIGINT
 
82
      || field->type() == Table::Field::SMALLINT
 
83
      || field->type() == Table::Field::TINYINT) {
 
84
    if (field->has_constraints()
 
85
        && field->constraints().has_is_unsigned())
 
86
      if (field->constraints().is_unsigned())
 
87
        cout << " UNSIGNED";
 
88
 
 
89
    if (field->has_numeric_options() &&
 
90
      field->numeric_options().is_autoincrement())
 
91
      cout << " AUTOINCREMENT ";
 
92
  }
 
93
 
 
94
  if (! field->has_constraints()
 
95
      && field->constraints().is_nullable())
85
96
    cout << " NOT NULL ";
86
97
 
87
 
  if (field->has_default_value())
88
 
    cout << " DEFAULT `" << field->default_value() << "` " ;
89
 
 
90
 
  if (field->on_update())
91
 
    cout << " ON UPDATE CURRENT_TIMESTAMP";
92
 
 
93
 
  if (field->autoincrement())
94
 
    cout << " AUTOINCREMENT ";
 
98
  if (field->type() == Table::Field::TEXT
 
99
      || field->type() == Table::Field::VARCHAR) {
 
100
    if (field->string_options().has_charset())
 
101
      cout << " CHARACTER SET " << field->string_options().charset();
 
102
 
 
103
    if (field->string_options().has_collation())
 
104
      cout << " COLLATE " << field->string_options().collation();
 
105
  }
 
106
 
 
107
  if (field->options().has_default_value())
 
108
    cout << " DEFAULT `" << field->options().default_value() << "` " ;
 
109
 
 
110
  if (field->type() == Table::Field::TIMESTAMP)
 
111
    if (field->timestamp_options().has_auto_updates()
 
112
      && field->timestamp_options().auto_updates())
 
113
      cout << " ON UPDATE CURRENT_TIMESTAMP";
95
114
 
96
115
  if (field->has_comment())
97
116
    cout << " COMMENT `" << field->comment() << "` ";
98
117
}
99
118
 
100
 
void printTable(const drizzle::Table *table) 
 
119
void print_engine(const drizzle::Table::StorageEngine *engine) {
 
120
  using namespace drizzle;
 
121
  uint32_t x;
 
122
 
 
123
  cout << " ENGINE = " << engine->name()  << endl;
 
124
 
 
125
  for (x= 0; x < engine->option_size(); ++x) {
 
126
    const Table::StorageEngine::EngineOption option= engine->option(x);
 
127
    cout << "\t" << option.name() << " = " << option.value() << endl;
 
128
  }
 
129
}
 
130
 
 
131
void print_index(const drizzle::Table::Index *index) {
 
132
  using namespace drizzle;
 
133
  uint32_t x;
 
134
 
 
135
  if (index->is_primary())
 
136
    cout << " PRIMARY"; 
 
137
  else if (index->is_unique())
 
138
    cout << " UNIQUE"; 
 
139
  cout << " KEY `" << index->name() << "` (";
 
140
  {
 
141
    int x;
 
142
 
 
143
    for (x= 0; x < index->index_part_size() ; x++)
 
144
    {
 
145
      const Table::Index::IndexPart part= index->index_part(x);
 
146
 
 
147
      if (x != 0)
 
148
        cout << ",";
 
149
      cout << "`" << part.field().name() << "`";
 
150
      if (part.has_compare_length())
 
151
        cout << "(" << part.compare_length() << ")";
 
152
    }
 
153
    cout << ")";
 
154
  }
 
155
  cout << "\t";
 
156
}
 
157
 
 
158
void print_table(const drizzle::Table *table) 
101
159
{
 
160
  using namespace drizzle;
102
161
  uint32_t x;
103
162
 
104
 
  cout << "CREATE TABLE";
105
 
 
106
 
  if (table->temp())
107
 
    cout << " TEMPORARY";
108
 
 
109
 
  cout << " `" << table->name() << "` (" << endl;
 
163
  cout << "CREATE ";
 
164
 
 
165
  if (table->type() == Table::TEMPORARY)
 
166
    cout << "TEMPORARY ";
 
167
 
 
168
  cout << "TABLE `" << table->name() << "` (" << endl;
110
169
  
111
170
  for (x= 0; x < table->field_size() ; x++)
112
171
  {
113
 
    const drizzle::Table::Field field = table->field(x);
 
172
    const Table::Field field = table->field(x);
 
173
 
 
174
    if (x != 0)
 
175
      cout << "," << endl;
 
176
 
 
177
    print_field(&field);
 
178
  }
 
179
 
 
180
  for (x= 0; x < table->index_size() ; x++)
 
181
  {
 
182
    const Table::Index index= table->index(x);
114
183
 
115
184
    if (x != 0)
116
185
      cout << "," << endl;;
117
186
 
118
 
    cout << "\t`" << field.name() << "`";
119
 
    printType(&field);
120
 
  }
121
 
 
122
 
  for (x= 0; x < table->index_size() ; x++)
123
 
  {
124
 
    const drizzle::Table::Index index = table->index(x);
125
 
 
126
 
    cout << "," << endl;;
127
 
 
128
 
    cout << "\t";
129
 
 
130
 
    if (index.primary())
131
 
      cout << " PRIMARY KEY (`" << index.name() << "`)";
132
 
    else
133
 
    {
134
 
      int x;
135
 
 
136
 
      cout << " UNIQUE KEY `" << index.name() << "` (";
137
 
      for (x= 0; x < index.values_size() ; x++)
138
 
      {
139
 
        const drizzle::Table::KeyPart key= index.values(x);
140
 
 
141
 
        if (x != 0)
142
 
          cout << ",";
143
 
        cout << "`" << key.name() << "`";
144
 
      }
145
 
      cout << ")";
146
 
    }
 
187
    print_index(&index);
 
188
 
147
189
  }
148
190
  cout << endl;
149
191
 
150
192
  cout << ") " << endl;
151
 
  if (table->has_collation())
152
 
    cout << " COLLATE = `" << table->collation() << "` " << endl;;
153
 
  if (table->has_characterset())
154
 
    cout << " CHARACTER SET = `" << table->characterset() << "` " << endl;;
 
193
  
 
194
  print_engine(&table->engine());
 
195
 
 
196
  /*
 
197
  if (table->has_options())
 
198
    print_table_options(&table->options());
 
199
  if (table->has_stats())
 
200
    print_table_stats(&table->stats());
 
201
  */
155
202
  if (table->has_comment())
156
 
    cout << " COMMENT = `" << table->comment() << "` " << endl;;
157
 
  if (table->has_engine())
158
 
  if (table->has_data_directory())
159
 
    cout << " DATA DIRECTORY = `" << table->data_directory() << "` " << endl;;
160
 
  if (table->has_index_directory())
161
 
    cout << " INDEX DIRECTORY = `" << table->index_directory() << "`" << endl;
162
 
  cout << " ENGINE = " << table->engine() << ";"  << endl;
 
203
    cout << " COMMENT = `" << table->comment() << "` " << endl;
 
204
}
 
205
 
 
206
void print_table_stats(const drizzle::Table::TableStats *stats) {
 
207
  
 
208
}
 
209
 
 
210
void print_table_options(const drizzle::Table::TableOptions *options) {
 
211
  if (options->has_collation())
 
212
    cout << " COLLATE = `" << options->collation() << "` " << endl;
 
213
  if (options->has_charset())
 
214
    cout << " CHARACTER SET = `" << options->charset() << "` " << endl;
163
215
}
164
216
 
165
217
int main(int argc, char* argv[]) 
183
235
    }
184
236
  }
185
237
 
186
 
  printTable(&table);
 
238
  print_table(&table);
187
239
 
188
240
  return 0;
189
241
}