← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/serialize/table_writer.cc

  • Committer: Brian Aker
  • Date: 2008-11-16 02:03:36 UTC
  • mfrom: (584.2.8 drizzle-nofrm)
  • Revision ID: brian@tangent.org-20081116020336-89horp2vrgqoqv0f
Merge stewert

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/serialize/table_writer.cc
4
4
#include "table.pb.h"
5
5
using namespace std;
6
6
 
7
 
/* 
 
7
/*
8
8
  Written from Google proto example
9
9
*/
10
10
 
11
 
void fill_engine(drizzle::Table::StorageEngine *engine) {
 
11
void fill_engine(drizzle::Table::StorageEngine *engine)
 
12
{
12
13
  using namespace drizzle;
13
14
  using std::string;
14
15
  int16_t x;
27
28
  };
28
29
 
29
30
  /* Add some engine options */
30
 
  for (x= 0; x < 2; ++x) {
 
31
  for (x= 0; x < 2; x++)
 
32
  {
31
33
    option= engine->add_option();
32
34
    option->set_name(option_names[x]);
33
35
    option->set_value(option_values[x]);
35
37
  }
36
38
}
37
39
 
38
 
void new_index_to_table(
39
 
    drizzle::Table *table
40
 
    , const std::string name
41
 
    , uint16_t num_index_parts
42
 
    , uint32_t field_indexes[]
43
 
    , uint32_t compare_lengths[]
44
 
    , bool is_primary
45
 
    , bool is_unique
46
 
    ) {
 
40
void new_index_to_table( drizzle::Table *table,
 
41
                         const std::string name,
 
42
                         uint16_t num_index_parts,
 
43
                         uint32_t field_indexes[],
 
44
                         uint32_t compare_lengths[],
 
45
                         bool is_primary,
 
46
                         bool is_unique)
 
47
{
47
48
  using namespace drizzle;
48
49
  uint16_t x;
49
50
 
58
59
  index->set_is_primary(is_primary);
59
60
  index->set_is_unique(is_unique);
60
61
 
61
 
  while (x < num_index_parts) {
62
 
 
 
62
  while (x < num_index_parts)
 
63
  {
63
64
    index_part= index->add_index_part();
64
65
 
65
66
    field= index_part->mutable_field();
72
73
  }
73
74
}
74
75
 
75
 
void fill_table(drizzle::Table *table, const char *name) 
 
76
void fill_table(drizzle::Table *table, const char *name)
76
77
{
77
78
  uint16_t x;
78
79
 
108
109
    if (x % 3)
109
110
    {
110
111
      string_field_options->set_collation("utf8_swedish_ci");
111
 
      string_field_options->set_charset("utf8");
112
112
    }
113
113
  }
114
114
 
136
136
    field->set_name("some_btye_string");
137
137
    field->set_type(Table::Field::BLOB);
138
138
  }
 
139
 
139
140
  /* Write out a DECIMAL */
140
141
  {
141
142
    field= table->add_field();
144
145
 
145
146
    field_constraints= field->mutable_constraints();
146
147
    field_constraints->set_is_nullable(true);
147
 
    
 
148
 
148
149
    numeric_field_options= field->mutable_numeric_options();
149
150
    numeric_field_options->set_precision(8);
150
151
    numeric_field_options->set_scale(3);
151
152
  }
152
153
 
153
154
  {
154
 
  uint32_t fields_in_index[1]= {6};
155
 
  uint32_t compare_lengths_in_index[1]= {0};
156
 
  bool is_unique= true;
157
 
  bool is_primary= false;
158
 
  /* Add a single-column index on important_number field */
159
 
  new_index_to_table(
160
 
      table
161
 
    , "idx_important_decimal"
162
 
    , 1
163
 
    , fields_in_index
164
 
    , compare_lengths_in_index
165
 
    , is_primary
166
 
    , is_unique
167
 
    );
 
155
    uint32_t fields_in_index[1]= {6};
 
156
    uint32_t compare_lengths_in_index[1]= {0};
 
157
    bool is_unique= true;
 
158
    bool is_primary= false;
 
159
    /* Add a single-column index on important_number field */
 
160
    new_index_to_table(table, "idx_important_decimal", 1, fields_in_index, compare_lengths_in_index, is_primary, is_unique);
168
161
  }
169
162
 
170
163
  {
171
 
  /* Add a double-column index on first two varchar fields */
172
 
  uint32_t fields_in_index[2]= {0,1};
173
 
  uint32_t compare_lengths_in_index[2]= {20,35};
174
 
  bool is_unique= true;
175
 
  bool is_primary= true;
176
 
  new_index_to_table(
177
 
      table
178
 
    , "idx_varchar1_2"
179
 
    , 2
180
 
    , fields_in_index
181
 
    , compare_lengths_in_index
182
 
    , is_primary
183
 
    , is_unique
184
 
    );
 
164
    /* Add a double-column index on first two varchar fields */
 
165
    uint32_t fields_in_index[2]= {0,1};
 
166
    uint32_t compare_lengths_in_index[2]= {20,35};
 
167
    bool is_unique= true;
 
168
    bool is_primary= true;
 
169
    new_index_to_table(table, "idx_varchar1_2", 2, fields_in_index, compare_lengths_in_index, is_primary, is_unique);
185
170
  }
186
171
 
187
172
  /* Do engine-specific stuff */
190
175
 
191
176
}
192
177
 
193
 
int main(int argc, char* argv[]) 
 
178
int main(int argc, char* argv[])
194
179
{
195
180
  GOOGLE_PROTOBUF_VERIFY_VERSION;
196
181
 
197
 
  if (argc != 2) {
 
182
  if (argc != 2)
 
183
  {
198
184
    cerr << "Usage:  " << argv[0] << " SCHEMA" << endl;
199
185
    return -1;
200
186
  }
204
190
  fill_table(&table, "example_table");
205
191
 
206
192
  fstream output(argv[1], ios::out | ios::trunc | ios::binary);
207
 
  if (!table.SerializeToOstream(&output)) 
 
193
  if (!table.SerializeToOstream(&output))
208
194
  {
209
195
    cerr << "Failed to write schema." << endl;
210
196
    return -1;