← Back to branch summary

~2591kuldeep/libdrizzle/libdrizzle-binlogapi

« back to all changes in this revision

Viewing changes to libdrizzle/helper.cc

  • Committer: kuldeep
  • Date: 2013-09-19 22:27:25 UTC
  • Revision ID: kuldeep@kuldeep-laptop-20130919222725-xsb4tlxp0tp3mm2t
Adding Tested code on local environment, now we can access the new api functions within library

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/helper.cc
 
1
/* 
 
2
 * Copyright (C) 2013 Drizzle Developer Group
 
3
 * Copyright (C) 2013 Kuldeep Porwal
 
4
 * All rights reserved.
 
5
 *
 
6
 * Use and distribution licensed under the BSD license.  See
 
7
 * the COPYING file in the parent directory for full text.
 
8
 *
 
9
 * summary: Utility functions to parse event data
 
10
 *
 
11
 */
 
12
#include "config.h"
 
13
#include<iostream>
 
14
#include "libdrizzle/common.h"
 
15
#include <stdio.h>
 
16
#include <stdlib.h>
 
17
#include <errno.h>
 
18
#include <inttypes.h>
 
19
#include<string.h>
 
20
#include<sstream>
 
21
#include<libdrizzle-5.1/helper.h>
 
22
 
 
23
using namespace std;
 
24
 
 
25
uint32_t getByte4(int pos,const unsigned char* data)
 
26
{
 
27
        if((int)(sizeof(data)-pos)<4)
 
28
        {
 
29
                return UINT_MAX;
 
30
        }
 
31
        uint32_t tmpMask = mask(32); // all 32 bits set to 1            
 
32
        
 
33
        tmpMask=((uint32_t)data[pos]&tmpMask);
 
34
        tmpMask=((uint32_t)data[pos+1]<<8|tmpMask);
 
35
        tmpMask=((uint32_t)data[pos+2]<<16|tmpMask);
 
36
        tmpMask=((uint32_t)data[pos+3]<<24|tmpMask);
 
37
        
 
38
        return tmpMask;
 
39
}
 
40
 
 
41
uint32_t getByte3(int pos,const unsigned char* data)
 
42
{
 
43
        if((int)(sizeof(data)-pos)<3)
 
44
        {
 
45
                return UINT_MAX;
 
46
        }
 
47
        uint32_t tmpMask = mask(32); // all 32 bits set to 1            
 
48
 
 
49
        tmpMask=((uint32_t)data[pos]&tmpMask);
 
50
        tmpMask=((uint32_t)data[pos+1]<<8|tmpMask);
 
51
        tmpMask=((uint32_t)data[pos+2]<<16|tmpMask);
 
52
        
 
53
        return tmpMask;
 
54
}
 
55
 
 
56
uint16_t getByte2(int pos,const unsigned char* data)
 
57
{
 
58
        if((int)sizeof(data)-pos<2)
 
59
        {
 
60
                return USHRT_MAX;
 
61
        }
 
62
        uint16_t tmpMask = mask(16); // all 16 bits set to 1            
 
63
 
 
64
        tmpMask=((uint16_t)data[pos]&tmpMask);
 
65
        tmpMask=((uint16_t)data[pos+1]<<8|tmpMask);
 
66
 
 
67
        return tmpMask;
 
68
}
 
69
 
 
70
 
 
71
uint64_t getByte6(int pos,const unsigned char* data)
 
72
{
 
73
        if((int)sizeof(data)-pos<6)
 
74
        {
 
75
                return UINT_MAX;
 
76
        }
 
77
        uint64_t tmpMask = mask(64); // all 64 bits set to 1            
 
78
 
 
79
        tmpMask=((uint64_t)data[pos]&tmpMask);
 
80
        tmpMask=((uint64_t)data[pos+1]<<8|tmpMask);
 
81
        tmpMask=((uint64_t)data[pos+2]<<16|tmpMask);
 
82
        tmpMask=((uint64_t)data[pos+3]<<24|tmpMask);
 
83
        tmpMask=((uint64_t)data[pos+4]<<32|tmpMask);
 
84
        tmpMask=((uint64_t)data[pos+5]<<40|tmpMask);
 
85
 
 
86
        return tmpMask;
 
87
}
 
88
 
 
89
uint64_t getByte8(int pos,const unsigned char* data)
 
90
{
 
91
        if((int)sizeof(data)-pos<8)
 
92
        {
 
93
                return UINT_MAX;
 
94
        }
 
95
        uint64_t tmpMask = mask(64); // all 64 bits set to 1            
 
96
 
 
97
        tmpMask=((uint64_t)data[pos]&tmpMask);
 
98
        tmpMask=((uint64_t)data[pos+1]<<8|tmpMask);
 
99
        tmpMask=((uint64_t)data[pos+2]<<16|tmpMask);
 
100
        tmpMask=((uint64_t)data[pos+3]<<24|tmpMask);
 
101
        tmpMask=((uint64_t)data[pos+4]<<32|tmpMask);
 
102
        tmpMask=((uint64_t)data[pos+5]<<40|tmpMask);
 
103
        tmpMask=((uint64_t)data[pos+5]<<48|tmpMask);
 
104
        tmpMask=((uint64_t)data[pos+5]<<56|tmpMask);
 
105
 
 
106
        return tmpMask;
 
107
}
 
108
 
 
109
char * getString(int pos,int len,const unsigned char * data)
 
110
{
 
111
        if((int)sizeof(data)-pos<len)
 
112
        {
 
113
                return NULL;
 
114
        }
 
115
        char *tmp = (char *)malloc(sizeof(char)*(len));
 
116
        int i;
 
117
        for(i=pos;i<pos+len;i++)
 
118
        {
 
119
                tmp[i-pos]=data[i];
 
120
        }
 
121
        tmp[i-pos]='\0';
 
122
        return tmp;
 
123
}
 
124
 
 
125
std::string getIntToStr(uint64_t num)
 
126
{
 
127
        std::stringstream ss;
 
128
        ss << num;
 
129
        std::string str=ss.str();
 
130
        return str;
 
131
}
 
132
 
 
133
uint64_t getEncodedLen(int& pos, const unsigned char *data)
 
134
{
 
135
        uint64_t len=0;
 
136
        if((int)sizeof(data)-pos<1)
 
137
        {
 
138
                return 0;
 
139
        }
 
140
 
 
141
        int colBytes = bytes_col_count((uint32_t)data[pos]);
 
142
        if((int)sizeof(data)-pos-1<colBytes)
 
143
        {
 
144
                pos++;
 
145
                return 0;
 
146
        }
 
147
        switch(colBytes)
 
148
        {   
 
149
                case 1:
 
150
                        len= (uint64_t)data[pos];
 
151
                        break;
 
152
 
 
153
                case 2:
 
154
                        len= (uint64_t)getByte2(pos+1,data);
 
155
                        break;
 
156
                case 3:
 
157
                        len= (uint64_t)getByte3(pos+1,data);
 
158
                        break;
 
159
                case 8:
 
160
                        len= (uint64_t)getByte8(pos+1,data);
 
161
                        break;
 
162
                default:
 
163
                        break;
 
164
        }   
 
165
        pos+=colBytes+(colBytes>1)?1:0; // include first byte if colCount>1
 
166
 
 
167
        return len;
 
168
}
 
169
 
 
170
bool getNextBit(uint8_t& val)
 
171
{
 
172
        val = val >> 1;
 
173
        return (val & 1);
 
174
}
 
175
int getBoolArray(bool arr[],const unsigned char data[],int start_pos,int _byte,int _bit)
 
176
{
 
177
        if((int)sizeof(data)-start_pos<_byte)
 
178
        {
 
179
                return -1;
 
180
        }
 
181
        int count=0;
 
182
        for(int i=0;i<_byte;i++)
 
183
        {   
 
184
                if(8*i>=_bit)
 
185
                        break;
 
186
                uint8_t number= (uint8_t)data[start_pos+i];
 
187
                arr[8*i] = (int)number&(int)1;
 
188
                if(arr[8*i]==0)
 
189
                        count++;
 
190
                for(int val=1;val<8;val++)
 
191
                {   
 
192
                        if((8*i+val) >= _bit)
 
193
                                break;
 
194
                        arr[8*i+val] = getNextBit(number);
 
195
                        if(arr[8*i+val]==0)
 
196
                                count++;
 
197
                }   
 
198
        }
 
199
        return count; // count where bit in not set. (0)
 
200
 
 
201
}
 
202
int lookup_metadata_field_size(enum_field_types field_type)
 
203
{
 
204
        switch (field_type)
 
205
        {
 
206
                case MYSQL_TYPE_DOUBLE:
 
207
                case MYSQL_TYPE_FLOAT:
 
208
                case MYSQL_TYPE_BLOB:
 
209
                case MYSQL_TYPE_GEOMETRY:
 
210
                        return 1;
 
211
                case MYSQL_TYPE_BIT:
 
212
                case MYSQL_TYPE_VARCHAR:
 
213
                case MYSQL_TYPE_NEWDECIMAL:
 
214
                case MYSQL_TYPE_STRING:
 
215
                case MYSQL_TYPE_VAR_STRING:
 
216
                        return 2;
 
217
                case MYSQL_TYPE_DECIMAL:
 
218
                case MYSQL_TYPE_SET:
 
219
                case MYSQL_TYPE_ENUM:
 
220
                case MYSQL_TYPE_YEAR:
 
221
                case MYSQL_TYPE_TINY:
 
222
                case MYSQL_TYPE_SHORT:
 
223
                case MYSQL_TYPE_INT24:
 
224
                case MYSQL_TYPE_LONG:
 
225
                case MYSQL_TYPE_LONGLONG:
 
226
                case MYSQL_TYPE_NEWDATE:
 
227
                case MYSQL_TYPE_DATE:
 
228
                case MYSQL_TYPE_TIME:
 
229
                case MYSQL_TYPE_TIMESTAMP:
 
230
                case MYSQL_TYPE_DATETIME:
 
231
                case MYSQL_TYPE_TINY_BLOB:
 
232
                case MYSQL_TYPE_MEDIUM_BLOB:
 
233
                case MYSQL_TYPE_LONG_BLOB:
 
234
                case MYSQL_TYPE_NULL:
 
235
                default:
 
236
                        return 0;
 
237
        }
 
238
 
 
239
}
 
240
 
 
241
enum_field_bytes lookup_field_bytes(enum_field_types field_type)
 
242
{
 
243
        switch (field_type)
 
244
        {
 
245
                case MYSQL_TYPE_DECIMAL:
 
246
                case MYSQL_TYPE_TIMESTAMP:
 
247
                case MYSQL_TYPE_DATE:
 
248
                case MYSQL_TYPE_TIME:
 
249
                case MYSQL_TYPE_DATETIME:
 
250
                case MYSQL_TYPE_NEWDATE:
 
251
                case MYSQL_TYPE_VARCHAR:
 
252
                case MYSQL_TYPE_BIT:
 
253
                case MYSQL_TYPE_NEWDECIMAL:
 
254
                case MYSQL_TYPE_TINY_BLOB:
 
255
                case MYSQL_TYPE_MEDIUM_BLOB:
 
256
                case MYSQL_TYPE_LONG_BLOB:
 
257
                case MYSQL_TYPE_BLOB:
 
258
                case MYSQL_TYPE_VAR_STRING:
 
259
                case MYSQL_TYPE_STRING:
 
260
                        return LEN_ENC_STR;
 
261
                
 
262
                case MYSQL_TYPE_TINY:
 
263
                        return READ_1_BYTE;
 
264
                
 
265
                case MYSQL_TYPE_SHORT:
 
266
                case MYSQL_TYPE_YEAR:
 
267
                        return READ_2_BYTE;
 
268
                
 
269
                case MYSQL_TYPE_LONG:
 
270
                case MYSQL_TYPE_FLOAT:
 
271
                case MYSQL_TYPE_INT24:
 
272
                        return READ_4_BYTE;
 
273
                
 
274
                case MYSQL_TYPE_DOUBLE:
 
275
                case MYSQL_TYPE_LONGLONG:
 
276
                        return READ_8_BYTE;
 
277
                
 
278
                case MYSQL_TYPE_NULL:
 
279
                case MYSQL_TYPE_ENUM:
 
280
                case MYSQL_TYPE_SET:
 
281
                case MYSQL_TYPE_GEOMETRY:
 
282
                default:
 
283
                        return NOT_FOUND;
 
284
 
 
285
        }
 
286
}