drizzle
C++ MySQL-protocol-compatible database server
Loading...
Searching...
No Matches
transaction_writer.cc
1/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2 * vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3 *
4 * Copyright (C) 2009 Sun Microsystems, Inc.
5 *
6 * Authors:
7 *
8 * Jay Pipes <[email protected]>
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; version 2 of the License.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
22 */
23
24#include <config.h>
25#include <drizzled/algorithm/crc32.h>
26#include <drizzled/gettext.h>
27#include <drizzled/replication_services.h>
28
29#include <sys/types.h>
30#include <sys/stat.h>
31#include <fcntl.h>
32#include <string>
33#include <fstream>
34#include <unistd.h>
35#include <sys/time.h>
36#include <time.h>
37
38#include <drizzled/message/transaction.pb.h>
39
40#include <google/protobuf/io/coded_stream.h>
41#include <google/protobuf/io/zero_copy_stream_impl.h>
42
43#include <drizzled/gettext.h>
44
48
49using namespace std;
50using namespace drizzled;
51using namespace google;
52
53static uint32_t server_id= 1;
54static uint64_t transaction_id= 1;
55
56static uint64_t getNanoTimestamp()
57{
58 struct timespec tp;
59 clock_gettime(CLOCK_REALTIME, &tp);
60 return (uint64_t) tp.tv_sec * 10000000
61 + (uint64_t) tp.tv_nsec;
62}
63
64static void initTransactionContext(message::Transaction &transaction)
65{
66 message::TransactionContext *ctx= transaction.mutable_transaction_context();
67 ctx->set_transaction_id(transaction_id++);
68 ctx->set_start_timestamp(getNanoTimestamp());
69 ctx->set_server_id(server_id);
70}
71
72static void finalizeTransactionContext(message::Transaction &transaction)
73{
74 message::TransactionContext *ctx= transaction.mutable_transaction_context();
75 ctx->set_end_timestamp(getNanoTimestamp());
76}
77
78static void doCreateTable1(message::Transaction &transaction)
79{
80 message::Statement *statement= transaction.add_statement();
81
82 statement->set_type(message::Statement::RAW_SQL);
83 statement->set_sql("CREATE TABLE t1 (a VARCHAR(32) NOT NULL, PRIMARY KEY a) ENGINE=InnoDB");
84 statement->set_start_timestamp(getNanoTimestamp());
85 statement->set_end_timestamp(getNanoTimestamp());
86}
87
88static void doCreateTable2(message::Transaction &transaction)
89{
90 message::Statement *statement= transaction.add_statement();
91
92 statement->set_type(message::Statement::RAW_SQL);
93 statement->set_sql("CREATE TABLE t2 (a INTEGER NOT NULL, PRIMARY KEY a) ENGINE=InnoDB");
94 statement->set_start_timestamp(getNanoTimestamp());
95 statement->set_end_timestamp(getNanoTimestamp());
96}
97
98static void doCreateTable3(message::Transaction &transaction)
99{
100 message::Statement *statement= transaction.add_statement();
101
102 statement->set_type(message::Statement::RAW_SQL);
103 statement->set_sql("CREATE TABLE t3 (a INTEGER NOT NULL, b BLOB NOT NULL, PRIMARY KEY a) ENGINE=InnoDB");
104 statement->set_start_timestamp(getNanoTimestamp());
105 statement->set_end_timestamp(getNanoTimestamp());
106}
107
108static void doSimpleInsert(message::Transaction &transaction)
109{
110 message::Statement *statement= transaction.add_statement();
111
112 /* Do generic Statement setup */
113 statement->set_type(message::Statement::INSERT);
114 statement->set_sql("INSERT INTO t1 (a) VALUES (\"1\"), (\"2\")");
115 statement->set_start_timestamp(getNanoTimestamp());
116
117 /* Do INSERT-specific header and setup */
118 message::InsertHeader *header= statement->mutable_insert_header();
119
120 /* Add table and field metadata for the statement */
121 message::TableMetadata *t_meta= header->mutable_table_metadata();
122 t_meta->set_schema_name("test");
123 t_meta->set_table_name("t1");
124
125 message::FieldMetadata *f_meta= header->add_field_metadata();
126 f_meta->set_name("a");
127 f_meta->set_type(message::Table::Field::VARCHAR);
128
129 /* Add new values... */
130 message::InsertData *data= statement->mutable_insert_data();
131 data->set_segment_id(1);
132 data->set_end_segment(true);
133
134 message::InsertRecord *record1= data->add_record();
135 message::InsertRecord *record2= data->add_record();
136
137 record1->add_insert_value("1");
138 record2->add_insert_value("2");
139
140 statement->set_end_timestamp(getNanoTimestamp());
141}
142
143static void doNonVarcharInsert(message::Transaction &transaction)
144{
145 message::Statement *statement= transaction.add_statement();
146
147 /* Do generic Statement setup */
148 statement->set_type(message::Statement::INSERT);
149 statement->set_sql("INSERT INTO t2 (a) VALUES (1), (2)");
150 statement->set_start_timestamp(getNanoTimestamp());
151
152 /* Do INSERT-specific header and setup */
153 message::InsertHeader *header= statement->mutable_insert_header();
154
155 /* Add table and field metadata for the statement */
156 message::TableMetadata *t_meta= header->mutable_table_metadata();
157 t_meta->set_schema_name("test");
158 t_meta->set_table_name("t2");
159
160 message::FieldMetadata *f_meta= header->add_field_metadata();
161 f_meta->set_name("a");
162 f_meta->set_type(message::Table::Field::INTEGER);
163
164 /* Add new values... */
165 message::InsertData *data= statement->mutable_insert_data();
166 data->set_segment_id(1);
167 data->set_end_segment(true);
168
169 message::InsertRecord *record1= data->add_record();
170 message::InsertRecord *record2= data->add_record();
171
172 record1->add_insert_value("1");
173 record2->add_insert_value("2");
174
175 statement->set_end_timestamp(getNanoTimestamp());
176}
177
178static void doBlobInsert(message::Transaction &transaction)
179{
180 message::Statement *statement= transaction.add_statement();
181
182 /* Do generic Statement setup */
183 statement->set_type(message::Statement::INSERT);
184 statement->set_sql("INSERT INTO t3 (a, b) VALUES (1, 'test\0me')", 43); /* 43 == length including \0 */
185 statement->set_start_timestamp(getNanoTimestamp());
186
187 /* Do INSERT-specific header and setup */
188 message::InsertHeader *header= statement->mutable_insert_header();
189
190 /* Add table and field metadata for the statement */
191 message::TableMetadata *t_meta= header->mutable_table_metadata();
192 t_meta->set_schema_name("test");
193 t_meta->set_table_name("t3");
194
195 message::FieldMetadata *f_meta= header->add_field_metadata();
196 f_meta->set_name("a");
197 f_meta->set_type(message::Table::Field::INTEGER);
198
199 f_meta= header->add_field_metadata();
200 f_meta->set_name("b");
201 f_meta->set_type(message::Table::Field::BLOB);
202
203 /* Add new values... */
204 message::InsertData *data= statement->mutable_insert_data();
205 data->set_segment_id(1);
206 data->set_end_segment(true);
207
208 message::InsertRecord *record1= data->add_record();
209
210 record1->add_insert_value("1");
211 record1->add_insert_value("test\0me", 7); /* 7 == length including \0 */
212
213 statement->set_end_timestamp(getNanoTimestamp());
214}
215
216static void doSimpleDelete(message::Transaction &transaction)
217{
218 message::Statement *statement= transaction.add_statement();
219
220 /* Do generic Statement setup */
221 statement->set_type(message::Statement::DELETE);
222 statement->set_sql("DELETE FROM t1 WHERE a = \"1\"");
223 statement->set_start_timestamp(getNanoTimestamp());
224
225 /* Do DELETE-specific header and setup */
226 message::DeleteHeader *header= statement->mutable_delete_header();
227
228 /* Add table and field metadata for the statement */
229 message::TableMetadata *t_meta= header->mutable_table_metadata();
230 t_meta->set_schema_name("test");
231 t_meta->set_table_name("t1");
232
233 message::FieldMetadata *f_meta= header->add_key_field_metadata();
234 f_meta->set_name("a");
235 f_meta->set_type(message::Table::Field::VARCHAR);
236
237 /* Add new values... */
238 message::DeleteData *data= statement->mutable_delete_data();
239 data->set_segment_id(1);
240 data->set_end_segment(true);
241
242 message::DeleteRecord *record1= data->add_record();
243
244 record1->add_key_value("1");
245
246 statement->set_end_timestamp(getNanoTimestamp());
247}
248
249static void doSimpleUpdate(message::Transaction &transaction)
250{
251 message::Statement *statement= transaction.add_statement();
252
253 /* Do generic Statement setup */
254 statement->set_type(message::Statement::UPDATE);
255 statement->set_sql("UPDATE t1 SET a = \"5\" WHERE a = \"1\"");
256 statement->set_start_timestamp(getNanoTimestamp());
257
258 /* Do UPDATE-specific header and setup */
259 message::UpdateHeader *header= statement->mutable_update_header();
260
261 /* Add table and field metadata for the statement */
262 message::TableMetadata *t_meta= header->mutable_table_metadata();
263 t_meta->set_schema_name("test");
264 t_meta->set_table_name("t1");
265
266 message::FieldMetadata *kf_meta= header->add_key_field_metadata();
267 kf_meta->set_name("a");
268 kf_meta->set_type(message::Table::Field::VARCHAR);
269
270 message::FieldMetadata *sf_meta= header->add_set_field_metadata();
271 sf_meta->set_name("a");
272 sf_meta->set_type(message::Table::Field::VARCHAR);
273
274 /* Add new values... */
275 message::UpdateData *data= statement->mutable_update_data();
276 data->set_segment_id(1);
277 data->set_end_segment(true);
278
279 message::UpdateRecord *record1= data->add_record();
280
281 record1->add_after_value("5");
282 record1->add_key_value("1");
283
284 statement->set_end_timestamp(getNanoTimestamp());
285}
286
287static void doMultiKeyUpdate(message::Transaction &transaction)
288{
289 message::Statement *statement= transaction.add_statement();
290
291 /* Do generic Statement setup */
292 statement->set_type(message::Statement::UPDATE);
293 statement->set_sql("UPDATE t1 SET a = \"5\"");
294 statement->set_start_timestamp(getNanoTimestamp());
295
296 /* Do UPDATE-specific header and setup */
297 message::UpdateHeader *header= statement->mutable_update_header();
298
299 /* Add table and field metadata for the statement */
300 message::TableMetadata *t_meta= header->mutable_table_metadata();
301 t_meta->set_schema_name("test");
302 t_meta->set_table_name("t1");
303
304 message::FieldMetadata *kf_meta= header->add_key_field_metadata();
305 kf_meta->set_name("a");
306 kf_meta->set_type(message::Table::Field::VARCHAR);
307
308 message::FieldMetadata *sf_meta= header->add_set_field_metadata();
309 sf_meta->set_name("a");
310 sf_meta->set_type(message::Table::Field::VARCHAR);
311
312 /* Add new values... */
313 message::UpdateData *data= statement->mutable_update_data();
314 data->set_segment_id(1);
315 data->set_end_segment(true);
316
317 message::UpdateRecord *record1= data->add_record();
318 message::UpdateRecord *record2= data->add_record();
319
320 record1->add_after_value("5");
321 record1->add_key_value("1");
322 record2->add_after_value("5");
323 record2->add_key_value("2");
324
325 statement->set_end_timestamp(getNanoTimestamp());
326}
327
328static void writeTransaction(protobuf::io::CodedOutputStream *output, message::Transaction &transaction)
329{
330 std::string buffer("");
331 finalizeTransactionContext(transaction);
332 transaction.SerializeToString(&buffer);
333
334 size_t length= buffer.length();
335
336 output->WriteLittleEndian32(static_cast<uint32_t>(ReplicationServices::TRANSACTION));
337 output->WriteLittleEndian32(static_cast<uint32_t>(length));
338 output->WriteString(buffer);
339 output->WriteLittleEndian32(drizzled::algorithm::crc32(buffer.c_str(), length)); /* checksum */
340}
341
342int main(int argc, char* argv[])
343{
344 GOOGLE_PROTOBUF_VERIFY_VERSION;
345 int file;
346
347 if (argc != 2)
348 {
349 fprintf(stderr, _("Usage: %s TRANSACTION_LOG\n"), argv[0]);
350 return -1;
351 }
352
353 if ((file= open(argv[1], O_APPEND|O_CREAT|O_SYNC|O_WRONLY, S_IRWXU)) == -1)
354 {
355 fprintf(stderr, _("Cannot open file: %s\n"), argv[1]);
356 return -1;
357 }
358
359 protobuf::io::ZeroCopyOutputStream *raw_output= new protobuf::io::FileOutputStream(file);
360 protobuf::io::CodedOutputStream *coded_output= new protobuf::io::CodedOutputStream(raw_output);
361
362 /* Write a series of statements which test each type of Statement */
363 message::Transaction transaction;
364
365 /* Simple CREATE TABLE statements as raw sql */
366 initTransactionContext(transaction);
367 doCreateTable1(transaction);
368 writeTransaction(coded_output, transaction);
369 transaction.Clear();
370
371 initTransactionContext(transaction);
372 doCreateTable2(transaction);
373 writeTransaction(coded_output, transaction);
374 transaction.Clear();
375
376 /* Simple INSERT statement */
377 initTransactionContext(transaction);
378 doSimpleInsert(transaction);
379 writeTransaction(coded_output, transaction);
380 transaction.Clear();
381
382 /* Write a DELETE and an UPDATE in one transaction */
383 initTransactionContext(transaction);
384 doSimpleDelete(transaction);
385 doSimpleUpdate(transaction);
386 writeTransaction(coded_output, transaction);
387 transaction.Clear();
388
389 /* Test an INSERT into non-varchar columns */
390 initTransactionContext(transaction);
391 doNonVarcharInsert(transaction);
392 writeTransaction(coded_output, transaction);
393 transaction.Clear();
394
395 /* Write an UPDATE which affects >1 row */
396 initTransactionContext(transaction);
397 doMultiKeyUpdate(transaction);
398 writeTransaction(coded_output, transaction);
399 transaction.Clear();
400
401 /* Write an INSERT which writes BLOB data */
402 initTransactionContext(transaction);
403 doCreateTable3(transaction);
404 doBlobInsert(transaction);
405 writeTransaction(coded_output, transaction);
406 transaction.Clear();
407
408 delete coded_output;
409 delete raw_output;
410
411 return 0;
412}
TODO: Rename this file - func.h is stupid.
STL namespace.