← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/serialize/replication_event_writer.cc

  • Committer: Monty Taylor
  • Date: 2009-01-06 18:46:25 UTC
  • mto: This revision was merged to the branch mainline in revision 762.
  • Revision ID: mordred@inaugust.com-20090106184625-kqu7nsnwjwm5jv4s
Enabled dirty_close.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/serialize/replication_event_writer.cc
 
1
#include <iostream>
 
2
#include <fstream>
 
3
#include <unistd.h>
 
4
#include <sys/types.h>
 
5
#include <sys/stat.h>
 
6
#include <fcntl.h>
 
7
#include <string>
 
8
#include <uuid/uuid.h>
 
9
 
 
10
#include <drizzled/serialize/replication_event.pb.h>
 
11
using namespace std;
 
12
 
 
13
static uint64_t query_id= 0;
 
14
char transaction_id[37];
 
15
 
 
16
/*
 
17
  Example script for reader a Drizzle master replication list.
 
18
*/
 
19
 
 
20
void write_ddl(drizzle::Event *record, const char *sql)
 
21
{
 
22
  uuid_t uu;
 
23
 
 
24
  uuid_generate_time(uu);
 
25
  uuid_unparse(uu, transaction_id);
 
26
 
 
27
  using namespace drizzle;
 
28
  record->set_type(Event::DDL);
 
29
  record->set_autocommit(true);
 
30
  record->set_server_id("localhost");
 
31
  record->set_query_id(query_id++);
 
32
  record->set_transaction_id(transaction_id);
 
33
  record->set_schema("test");
 
34
  record->set_sql(sql);
 
35
}
 
36
 
 
37
void write_insert(drizzle::Event *record, const char *trx)
 
38
{
 
39
  using namespace drizzle;
 
40
  Event::Value *value;
 
41
 
 
42
  record->set_type(Event::INSERT);
 
43
  record->set_autocommit(true);
 
44
  record->set_server_id("localhost");
 
45
  record->set_query_id(query_id++);
 
46
  record->set_transaction_id(trx);
 
47
  record->set_schema("test");
 
48
  record->set_table("t1");
 
49
  record->set_sql("INSERT INTO t1 (a) VALUES (1) (2)");
 
50
 
 
51
  /* Add Field Names */
 
52
  record->add_field_names("a");
 
53
 
 
54
  /* Add values (first row) */
 
55
  value= record->add_values();
 
56
  value->add_value("1");
 
57
 
 
58
  /* Add values (second row) */
 
59
  value= record->add_values();
 
60
  value->add_value("2");
 
61
}
 
62
 
 
63
void write_delete(drizzle::Event *record, const char *trx)
 
64
{
 
65
  using namespace drizzle;
 
66
  uuid_t uu;
 
67
  Event::Value *value;
 
68
 
 
69
  record->set_type(Event::DELETE);
 
70
  record->set_autocommit(true);
 
71
  record->set_server_id("localhost");
 
72
  record->set_query_id(query_id++);
 
73
  record->set_transaction_id(trx);
 
74
  record->set_schema("test");
 
75
  record->set_table("t1");
 
76
  record->set_sql("DELETE FROM t1 WHERE a IN (1, 2)");
 
77
 
 
78
  /* Add Field Names */
 
79
  record->set_primary_key("a");
 
80
 
 
81
  /* Add values for IN() */
 
82
  value= record->add_values();
 
83
  value->add_value("1");
 
84
  value->add_value("2");
 
85
}
 
86
 
 
87
void write_update(drizzle::Event *record, const char *trx)
 
88
{
 
89
  using namespace drizzle;
 
90
  Event::Value *value;
 
91
 
 
92
  record->set_type(Event::UPDATE);
 
93
  record->set_autocommit(true);
 
94
  record->set_server_id("localhost");
 
95
  record->set_query_id(query_id++);
 
96
  record->set_transaction_id(trx);
 
97
  record->set_schema("test");
 
98
  record->set_table("t1");
 
99
  record->set_sql("UPDATE t1 SET a=5 WHERE a = 1 ");
 
100
  record->set_primary_key("a");
 
101
 
 
102
  /* Add Field Names */
 
103
  record->add_field_names("a");
 
104
 
 
105
  /* Add values (first row) */
 
106
  value= record->add_values();
 
107
  value->add_value("1"); // The first value is always the primary key comparison value
 
108
  value->add_value("5");
 
109
 
 
110
  /* Add values (second row) */
 
111
  value= record->add_values();
 
112
  value->add_value("2");
 
113
  value->add_value("6");
 
114
}
 
115
 
 
116
void write_to_disk(int file, drizzle::EventList *list)
 
117
{
 
118
  std::string buffer;
 
119
  uint64_t length;
 
120
  size_t written;
 
121
 
 
122
  list->SerializePartialToString(&buffer);
 
123
 
 
124
  length= buffer.length();
 
125
 
 
126
  cout << "Writing record of " << length << "." << endl;
 
127
 
 
128
  if ((written= write(file, &length, sizeof(uint64_t))) != sizeof(uint64_t))
 
129
  {
 
130
    cerr << "Only wrote " << written << " out of " << length << "." << endl;
 
131
    exit(1);
 
132
  }
 
133
 
 
134
  if ((written= write(file, buffer.c_str(), length)) != length)
 
135
  {
 
136
    cerr << "Only wrote " << written << " out of " << length << "." << endl;
 
137
    exit(1);
 
138
  }
 
139
}
 
140
 
 
141
 
 
142
int main(int argc, char* argv[])
 
143
{
 
144
  GOOGLE_PROTOBUF_VERIFY_VERSION;
 
145
  int file;
 
146
 
 
147
  if (argc != 2) 
 
148
  {
 
149
    cerr << "Usage:  " << argv[0] << " REPLICATION_EVENT_LOG " << endl;
 
150
    return -1;
 
151
  }
 
152
 
 
153
  if ((file= open(argv[1], O_APPEND|O_CREAT|O_SYNC|O_WRONLY, S_IRWXU)) == -1)
 
154
  {
 
155
    cerr << "Can not open file: " << argv[0] << endl;
 
156
   exit(0);
 
157
  }
 
158
 
 
159
  drizzle::EventList list;
 
160
 
 
161
  /* Write first set of records */
 
162
  write_ddl(list.add_event(), "CREATE TABLE A (a int) ENGINE=innodb");
 
163
  write_insert(list.add_event(), transaction_id);
 
164
 
 
165
  write_to_disk(file, &list);
 
166
 
 
167
  /* Write Second set of records */
 
168
  write_ddl(list.add_event(), "CREATE TABLE A (a int) ENGINE=innodb");
 
169
  write_delete(list.add_event(), transaction_id);
 
170
  write_update(list.add_event(), transaction_id);
 
171
 
 
172
  write_to_disk(file, &list);
 
173
 
 
174
  close(file);
 
175
 
 
176
  return 0;
 
177
}