← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzledump_data.h

  • Committer: Jay Pipes
  • Date: 2009-01-30 04:01:12 UTC
  • mto: This revision was merged to the branch mainline in revision 830.
  • Revision ID: jpipes@serialcoder-20090130040112-svbn774guj98pwi4
To remain in compatibility with MySQL, added ability to interpret
decimal arguments as datetime strings for temporal functions.

Fixed YEAR(), MONTH(), DAYOFMONTH(), DAYOFYEAR(), HOUR(), MINUTE(), SECOND(), and MICROSECOND()
to accept decimal parameters and interpret them the same way as MySQL.

Fixed an issue with the TemporalFormat::matches() method which was 
incorrectly assuming all microsecond arguments were specified as 6 digits.
Added power of 10 multiplier to usecond calculation. This fixes issues with
failures in type_date and func_sapdb test cases.

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzledump_data.h
1
 
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
 
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
 
 *
4
 
 *  Copyright (C) 2010 Andrew Hutchings
5
 
 *
6
 
 *  This program is free software; you can redistribute it and/or modify
7
 
 *  it under the terms of the GNU General Public License as published by
8
 
 *  the Free Software Foundation; version 2 of the License.
9
 
 *
10
 
 *  This program is distributed in the hope that it will be useful,
11
 
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13
 
 *  GNU General Public License for more details.
14
 
 *
15
 
 *  You should have received a copy of the GNU General Public License
16
 
 *  along with this program; if not, write to the Free Software
17
 
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
 
 */
19
 
 
20
 
#ifndef CLIENT_DRIZZLEDUMP_DATA_H
21
 
#define CLIENT_DRIZZLEDUMP_DATA_H
22
 
 
23
 
#define DRIZZLE_MAX_LINE_LENGTH 1024*1024L-1025
24
 
#include "client_priv.h"
25
 
#include <string>
26
 
#include <iostream>
27
 
#include <iomanip>
28
 
#include <vector>
29
 
#include <sstream>
30
 
#include <algorithm>
31
 
 
32
 
class DrizzleDumpConnection;
33
 
class DrizzleDumpDatabase;
34
 
class DrizzleDumpData;
35
 
 
36
 
class DrizzleDumpForeignKey
37
 
{
38
 
  public:
39
 
    DrizzleDumpConnection *dcon;
40
 
    std::string constraintName;
41
 
 
42
 
    DrizzleDumpForeignKey(std::string name, DrizzleDumpConnection* connection) :
43
 
      dcon(connection),
44
 
      constraintName(name)
45
 
    { }
46
 
 
47
 
    virtual ~DrizzleDumpForeignKey() { }
48
 
 
49
 
    std::string parentColumns;
50
 
    std::string childColumns;
51
 
    std::string childTable;
52
 
    std::string matchOption;
53
 
    std::string deleteRule;
54
 
    std::string updateRule;
55
 
 
56
 
    friend std::ostream& operator <<(std::ostream &os, const DrizzleDumpForeignKey &obj);
57
 
};
58
 
 
59
 
class DrizzleDumpIndex
60
 
{
61
 
  public:
62
 
    DrizzleDumpConnection *dcon;
63
 
    std::string indexName;
64
 
 
65
 
    DrizzleDumpIndex(std::string &index, DrizzleDumpConnection* connection) :
66
 
      dcon(connection),
67
 
      indexName(index),
68
 
      isPrimary(false),
69
 
      isUnique(false),
70
 
      isHash(false)
71
 
    { }
72
 
 
73
 
    virtual ~DrizzleDumpIndex() { }
74
 
 
75
 
    bool isPrimary;
76
 
    bool isUnique;
77
 
    bool isHash;
78
 
    uint32_t length;
79
 
 
80
 
    std::vector<std::string> columns;
81
 
    friend std::ostream& operator <<(std::ostream &os, const DrizzleDumpIndex &obj);
82
 
};
83
 
 
84
 
class DrizzleDumpField
85
 
{
86
 
  public:
87
 
    DrizzleDumpField(std::string &field, DrizzleDumpConnection* connection) :
88
 
      dcon(connection),
89
 
      fieldName(field),
90
 
      isNull(false),
91
 
      isUnsigned(false),
92
 
      isAutoIncrement(false),
93
 
      defaultIsNull(false),
94
 
      convertDateTime(false),
95
 
      rangeCheck(false)
96
 
    { }
97
 
 
98
 
    virtual ~DrizzleDumpField() { }
99
 
    DrizzleDumpConnection *dcon;
100
 
 
101
 
    std::stringstream errmsg;
102
 
 
103
 
    friend std::ostream& operator <<(std::ostream &os, const DrizzleDumpField &obj);
104
 
    std::string fieldName;
105
 
 
106
 
    std::string type;
107
 
    uint32_t length;
108
 
    bool isNull;
109
 
    bool isUnsigned;
110
 
    bool isAutoIncrement;
111
 
    bool defaultIsNull;
112
 
    bool convertDateTime;
113
 
    bool rangeCheck;
114
 
    std::string defaultValue;
115
 
    std::string collation;
116
 
    std::string comment;
117
 
 
118
 
    /* For enum type */
119
 
    std::string enumValues;
120
 
 
121
 
    /* For decimal/double */
122
 
    uint32_t decimalPrecision;
123
 
    uint32_t decimalScale;
124
 
 
125
 
    virtual void setType(const char*, const char*) { }
126
 
 
127
 
};
128
 
 
129
 
class DrizzleDumpTable
130
 
{
131
 
  public:
132
 
    DrizzleDumpTable(std::string &table, DrizzleDumpConnection* connection) :
133
 
      dcon(connection),
134
 
      tableName(table),
135
 
      database(NULL)
136
 
    { }
137
 
 
138
 
    virtual ~DrizzleDumpTable() { }
139
 
    DrizzleDumpConnection *dcon;
140
 
 
141
 
    std::stringstream errmsg;
142
 
 
143
 
    virtual bool populateFields() { return false; }
144
 
    virtual bool populateIndexes() { return false; }
145
 
    virtual bool populateFkeys() { return false; }
146
 
    virtual DrizzleDumpData* getData() { return NULL; }
147
 
    std::vector<DrizzleDumpField*> fields;
148
 
    std::vector<DrizzleDumpIndex*> indexes;
149
 
    std::vector<DrizzleDumpForeignKey*> fkeys;
150
 
 
151
 
    friend std::ostream& operator <<(std::ostream &os, const DrizzleDumpTable &obj);
152
 
    std::string tableName;
153
 
    std::string displayName;
154
 
    std::string engineName;
155
 
    std::string collate;
156
 
    std::string comment;
157
 
 
158
 
    // Currently MySQL only, hard to do in Drizzle
159
 
    uint64_t autoIncrement;
160
 
    DrizzleDumpDatabase* database;
161
 
};
162
 
 
163
 
class DrizzleDumpDatabase
164
 
{
165
 
  public:
166
 
    DrizzleDumpDatabase(const std::string &database, DrizzleDumpConnection* connection) :
167
 
      dcon(connection),
168
 
      databaseName(database)
169
 
    { }
170
 
    DrizzleDumpConnection *dcon;
171
 
 
172
 
    virtual ~DrizzleDumpDatabase() { }
173
 
 
174
 
    std::stringstream errmsg;
175
 
 
176
 
    friend std::ostream& operator <<(std::ostream &os, const DrizzleDumpDatabase &obj);
177
 
 
178
 
    virtual bool populateTables(void) { return false; }
179
 
    virtual bool populateTables(const std::vector<std::string> &table_names) { return table_names.empty(); }
180
 
    virtual void setCollate(const char*) { }
181
 
    void cleanTableName(std::string &tableName);
182
 
    bool ignoreTable(std::string tableName);
183
 
    std::vector<DrizzleDumpTable*> tables;
184
 
 
185
 
    const std::string databaseName;
186
 
    std::string collate;
187
 
};
188
 
 
189
 
class DrizzleDumpData
190
 
{
191
 
  public:
192
 
    DrizzleDumpConnection *dcon;
193
 
    std::stringstream errmsg;
194
 
    DrizzleDumpTable *table;
195
 
    drizzle_result_st *result;
196
 
    DrizzleDumpData(DrizzleDumpTable *dataTable, DrizzleDumpConnection *connection) :
197
 
      dcon(connection),
198
 
      table(dataTable),
199
 
      result(NULL)
200
 
    { }
201
 
 
202
 
    virtual ~DrizzleDumpData() { }
203
 
    friend std::ostream& operator <<(std::ostream &os, const DrizzleDumpData &obj);
204
 
 
205
 
    virtual std::string checkDateTime(const char*, uint32_t) const { return std::string(""); }
206
 
    std::string convertHex(const unsigned char* from, size_t from_size) const;
207
 
    static std::string escape(const char* from, size_t from_size);
208
 
};
209
 
 
210
 
class DrizzleDumpConnection
211
 
{
212
 
  private:
213
 
    drizzle_st drizzle;
214
 
    drizzle_con_st connection;
215
 
    std::string hostName;
216
 
    bool drizzleProtocol;
217
 
    int serverType;
218
 
 
219
 
  public:
220
 
    enum server_type {
221
 
      SERVER_MYSQL_FOUND,
222
 
      SERVER_DRIZZLE_FOUND,
223
 
      SERVER_UNKNOWN_FOUND
224
 
    };
225
 
    DrizzleDumpConnection(std::string &host, uint16_t port,
226
 
      std::string &username, std::string &password, bool drizzle_protocol);
227
 
    ~DrizzleDumpConnection();
228
 
    void errorHandler(drizzle_result_st *res,  drizzle_return_t ret, const char *when);
229
 
    drizzle_result_st* query(std::string &str_query);
230
 
    bool queryNoResult(std::string &str_query);
231
 
 
232
 
    drizzle_result_st* query(const char* ch_query)
233
 
    {
234
 
      std::string str_query(ch_query);
235
 
      return query(str_query);
236
 
    }
237
 
    bool queryNoResult(const char* ch_query)
238
 
    {
239
 
      std::string str_query(ch_query);
240
 
      return queryNoResult(str_query);
241
 
    }
242
 
 
243
 
    void freeResult(drizzle_result_st* result);
244
 
    bool setDB(std::string databaseName);
245
 
    bool usingDrizzleProtocol(void) const { return drizzleProtocol; }
246
 
    bool getServerType(void) const { return serverType; }
247
 
    const char* getServerVersion(void) { return drizzle_con_server_version(&connection); }
248
 
};
249
 
 
250
 
class DrizzleStringBuf : public std::streambuf
251
 
{
252
 
  public:
253
 
    DrizzleStringBuf(int size) :
254
 
      buffSize(size)
255
 
    {
256
 
      resize= 1;
257
 
      ptr.resize(buffSize);
258
 
      setp(&ptr[0], &ptr.back());
259
 
    }
260
 
    virtual ~DrizzleStringBuf() 
261
 
    {
262
 
        sync();
263
 
    }
264
 
 
265
 
    void writeString(std::string &str)
266
 
    {
267
 
      if (not connection->queryNoResult(str))
268
 
        throw std::exception();
269
 
    }
270
 
 
271
 
    void setConnection(DrizzleDumpConnection *conn) { connection= conn; }
272
 
 
273
 
  private:
274
 
    DrizzleDumpConnection *connection;
275
 
    size_t buffSize;
276
 
    uint32_t resize;
277
 
    std::vector<char> ptr;
278
 
 
279
 
    int overflow(int c)
280
 
    {
281
 
        if (c != EOF)
282
 
        {
283
 
          size_t len = size_t(pptr() - pbase());
284
 
          resize++;
285
 
          ptr.resize(buffSize*resize);
286
 
          setp(&ptr[0], &ptr.back());
287
 
          /* setp resets current pointer, put it back */
288
 
          pbump(len);
289
 
          sputc(c);
290
 
        }
291
 
 
292
 
        return 0;
293
 
    }
294
 
 
295
 
    int sync()
296
 
    {
297
 
      size_t len = size_t(pptr() - pbase());
298
 
      std::string temp(pbase(), len);
299
 
 
300
 
      /* Drop newlines */
301
 
      temp.erase(std::remove(temp.begin(), temp.end(), '\n'), temp.end());
302
 
 
303
 
      if (temp.compare(0, 2, "--") == 0)
304
 
      {
305
 
        /* Drop comments */
306
 
        setp(pbase(), epptr());
307
 
      }
308
 
      if (temp.find(";") != std::string::npos)
309
 
      {
310
 
        writeString(temp);
311
 
        setp(pbase(), epptr());
312
 
      }
313
 
      return 0;
314
 
    }
315
 
};
316
 
 
317
 
#endif /* CLIENT_DRIZZLEDUMP_DATA_H */