DCL 3.7.4
Loading...
Searching...
No Matches
PeParam Class Reference

#include <PeParam.h>

Inheritance diagram for PeParam:
SQL::Param SQL::Field Object

Public Member Functions

bool init (SQL::Query *_query, sqlvar_t *_sqlvar)
bool onAfterExecute ()
 PeParam ()
virtual ~PeParam ()
virtual const wchar_t * serverDataTypeName () const
virtual void setNull ()
virtual bool __setData (_CONST void *_val, size_t _size, SQL::DataType _valType, SQL::DataType _sqlType)
Public Member Functions inherited from Object
virtual String toString () const
virtual void destroy ()
String className () const
bool isInstanceOf (const std::type_info &typeinfo) const
virtual const std::type_info & typeInfo () const

Protected Member Functions

PeQuery * query () const
PeConnection * conn () const
Protected Member Functions inherited from SQL::Param
 Param (Query *_queryHandle)
virtual ~Param ()
virtual bool __setOutputType (DataType _sqlType)
virtual bool __getDataSize (size_t *_size, bool _maxsize)
virtual bool __getData (void *_buf, size_t *_size, DataType _bufType)
Protected Member Functions inherited from SQL::Field
 Field (Query *_queryHandle)
virtual ~Field ()
Protected Member Functions inherited from Object
virtual ~Object ()
 Object ()

Additional Inherited Members

Protected Attributes inherited from SQL::Field
Query * __queryHandle
String __name
DataType __dataType
short __precision
short __scale

Detailed Description

Definition at line 6 of file PeParam.h.

Constructor & Destructor Documentation

◆ PeParam()

PeParam::PeParam ( )

◆ ~PeParam()

PeParam::~PeParam ( )
virtual

Definition at line 60 of file PeParam.cpp.

61{
62}

Member Function Documentation

◆ __setData()

bool PeParam::__setData ( _CONST void * _val,
size_t _size,
SQL::DataType _valType,
SQL::DataType _sqlType )
virtual

Implements SQL::Param.

Definition at line 127 of file PeParam.cpp.

133{
134 switch(_valType) {
135 case SQL::typeInteger: {
136 switch (_size) {
137 case sizeof(int8_t) : {
138 __data.i32 = (int32_t) * (int8_t*)_val;
139 __sqlvar->sqltype = ECPGt_int;
140 __sqlvar->sqllen = sizeof(int32_t);
141 __sqlvar->sqldata = (char*)&__data;
142 break;
143 }
144 case sizeof(int16_t) : {
145 __data.i32 = (int32_t) * (int16_t*)_val;
146 __sqlvar->sqltype = ECPGt_int;
147 __sqlvar->sqllen = sizeof(int32_t);
148 __sqlvar->sqldata = (char*)&__data;
149 break;
150 }
151 case sizeof(int32_t) : {
152 __data.i32 = *(int32_t*)_val;
153 __sqlvar->sqltype = ECPGt_int;
154 __sqlvar->sqllen = sizeof(int32_t);
155 __sqlvar->sqldata = (char*)&__data;
156 break;
157 }
158 case sizeof(int64_t) : {
159 __data.i64 = *(int64_t*)_val;
160#if ALIGNOF_LONG == 8
161 __sqlvar->sqltype = ECPGt_long;
162#else
163 __sqlvar->sqltype = ECPGt_long_long;
164#endif
165 __sqlvar->sqllen = sizeof(int64_t);
166 __sqlvar->sqldata = (char*)&__data;
167 break;
168 }
169 default: {
170 __SET_ERROR(SQL::eInvalidDataSize);
171 return false;
172 }
173 }
174 break;
175 }
176 case SQL::typeUInteger: {
177 switch (_size) {
178 case sizeof(uint8_t) : {
179 __data.i32 = (int32_t) * (uint8_t*)_val;
180 __sqlvar->sqltype = ECPGt_int;
181 __sqlvar->sqllen = sizeof(uint32_t);
182 __sqlvar->sqldata = (char*)&__data;
183 break;
184 }
185 case sizeof(uint16_t) : {
186 __data.i32 = (int32_t) * (uint16_t*)_val;
187 __sqlvar->sqltype = ECPGt_int;
188 __sqlvar->sqllen = sizeof(uint32_t);
189 __sqlvar->sqldata = (char*)&__data;
190 break;
191 }
192 case sizeof(uint32_t) : {
193 __data.i32 = (int32_t) * (uint32_t*)_val;
194 __sqlvar->sqltype = ECPGt_int;
195 __sqlvar->sqllen = sizeof(uint32_t);
196 __sqlvar->sqldata = (char*)&__data;
197 break;
198 }
199 case sizeof(uint64_t) : {
200 __data.i64 = (int64_t) * (uint64_t*)_val;
201#if ALIGNOF_LONG == 8
202 __sqlvar->sqltype = ECPGt_long;
203#else
204 __sqlvar->sqltype = ECPGt_long_long;
205#endif
206 __sqlvar->sqllen = sizeof(int64_t);
207 __sqlvar->sqldata = (char*)&__data;
208 break;
209 }
210 default: {
211 __SET_ERROR(SQL::eInvalidDataSize);
212 return false;
213 }
214 }
215 break;
216 }
217 case SQL::typeFloat: {
218 switch (_size) {
219 case sizeof(float) : {
220 __data.f32 = *(float*)_val;
221 __sqlvar->sqltype = ECPGt_float;
222 __sqlvar->sqllen = sizeof(float);
223 __sqlvar->sqldata = (char*)&__data;
224 break;
225 }
226 case sizeof(double) : {
227 __data.f64 = *(double*)_val;
228 __sqlvar->sqltype = ECPGt_double;
229 __sqlvar->sqllen = sizeof(double);
230 __sqlvar->sqldata = (char*)&__data;
231 break;
232 }
233 default: {
234 __SET_ERROR(SQL::eInvalidDataSize);
235 return false;
236 }
237 }
238 break;
239 }
240 case SQL::typeDate: {
241 if (_size == sizeof(SQL::Date)) {
242 __encode((const SQL::Date*)_val, &__data.dt);
243 __sqlvar->sqltype = ECPGt_date;
244 __sqlvar->sqllen = sizeof(date);
245 __sqlvar->sqldata = (char*)&__data;
246 }
247 else {
248 __SET_ERROR(SQL::eInvalidDataSize);
249 return false;
250 }
251 break;
252 }
253 case SQL::typeTime: {
254 if (_size == sizeof(SQL::Time)) {
255 __bytes = __encode((const SQL::Time*)_val);
256 __sqlvar->sqltype = ECPGt_char;
257 __sqlvar->sqllen = (short)__bytes.length();
258 __sqlvar->sqldata = (char*)__bytes.data();
259 }
260 else {
261 __SET_ERROR(SQL::eInvalidDataSize);
262 return false;
263 }
264 break;
265 }
266 case SQL::typeTimeStamp: {
267 if (_size == sizeof(SQL::TimeStamp)) {
268 const SQL::TimeStamp* p = (const SQL::TimeStamp*)_val;
269#if 0
270 if (p->tzoff != INT16_MIN) {
271 __SET_ERROR(SQL::eInvalidData);
272 return false;
273 }
274#endif
275 __encode(p, &__data.ts);
276 __sqlvar->sqltype = ECPGt_timestamp;
277 __sqlvar->sqllen = sizeof(timestamp);
278 __sqlvar->sqldata = (char*)&__data;
279 }
280 else {
281 __SET_ERROR(SQL::eInvalidDataSize);
282 return false;
283 }
284 break;
285 }
286 case SQL::typeInterval: {
287 if (_size == sizeof(SQL::Interval)) {
288 __encode((const SQL::Interval*)_val, &__data.ival);
289 __sqlvar->sqltype = ECPGt_interval;
290 __sqlvar->sqllen = sizeof(interval);
291 __sqlvar->sqldata = (char*)&__data;
292 }
293 else {
294 __SET_ERROR(SQL::eInvalidDataSize);
295 return false;
296 }
297 break;
298 }
299 case SQL::typeText: {
300 if (_sqlType == SQL::typeNumeric) {
301 if (_size > 0) {
302 numeric* p = PGTYPESnumeric_from_asc((char*)_val, NULL);
303 if (!p) {
304 __SET_ERROR(SQL::eInvalidData);
305 return false;
306 }
307 PGTYPESnumeric_copy(p, &__data.nu);
308 __sqlvar->sqltype = ECPGt_numeric;
309 __sqlvar->sqllen = sizeof(numeric);
310 __sqlvar->sqldata = (char*)&__data;
311 }
312 else {
313 __SET_ERROR(SQL::eInvalidDataSize);
314 return false;
315 }
316 break;
317 }
318#if __TRACE_THIS && 1
319 __DCL_TRACE2_N(L"_sqlType[%d] _size[%zd]\n",
320 _sqlType, _size);
321 __DCL_TRACE2_N(L"_val[%p] [%ls]\n", _val,
322 String::tryString((const char*)_val, _size).data());
323#endif
324 }
325 case SQL::typeBinary: {
326 switch (_sqlType) {
327 case SQL::typeText: // CHAR, VARCHAR
328 case SQL::typeLongText: {
329 __sqlvar->sqltype = ECPGt_char;
330 __sqlvar->sqllen = (short) _size;
331 __sqlvar->sqldata = (char*) _val;
332 break;
333 }
334 case SQL::typeBinary: // ECPGt_bytea 동작하지 않는다!
335 case SQL::typeLongBinary: {
336 __bytes = ByteString::toHexString(
337 (const char*)_val, _size, (size_t)-1, true);
338 if (__bytes.length() > INT16_MAX) {
339 __SET_ERROR(SQL::eInvalidDataSize);
340 return false;
341 }
342 __sqlvar->sqltype = ECPGt_char;
343 __sqlvar->sqllen = (short)__bytes.length();
344 __sqlvar->sqldata = (char*)__bytes.data();
345 break;
346 }
347 default: {
348 __SET_ERROR(SQL::eNotSupportDataType);
349 return false;
350 }
351 }
352 break;
353 }
354 case SQL::typeInputStream: {
355 try {
356 __bytes = Files::readBytes(*(InputStream*)_val, _size);
357 }
358 catch (IOException* e) {
359 __SET_ERROR_MSG(UTF8Encoder::encode(e->toStringAll()));
360 e->destroy();
361 return false;
362 }
363 if (__bytes.length() > INT16_MAX) {
364 __SET_ERROR(SQL::eInvalidDataSize);
365 return false;
366 }
367 __bytes = ByteString::toHexString(__bytes, (size_t)-1, true);
368 if (__bytes.length() > INT16_MAX) {
369 __SET_ERROR(SQL::eInvalidDataSize);
370 return false;
371 }
372 __sqlvar->sqltype = ECPGt_char;
373 __sqlvar->sqllen = (short) __bytes.length();
374 __sqlvar->sqldata = (char*)__bytes.data();
375 break;
376 }
377 default: {
378 __SET_ERROR(SQL::eNotSupportDataType);
379 return false;
380 }
381 }
382
383 __indicator = 0;
384 Param::__dataType = _sqlType;
385 return true;
386}
NULL
#define NULL
Definition Config.h:312
INT16_MAX
#define INT16_MAX
Definition Config.h:289
INT16_MIN
#define INT16_MIN
Definition Config.h:284
__DCL_TRACE2_N
#define __DCL_TRACE2_N(fmt, arg1, arg2)
Definition HttpCollection.cpp:36
__SET_ERROR_MSG
#define __SET_ERROR_MSG(_message)
Definition IFXConnection.cpp:50
__encode
void __encode(const SQL::Date *_s, date *_r)
Definition PeTypes.cpp:37
__SET_ERROR
#define __SET_ERROR(_errorCode)
Definition SQLCore.cpp:149
Exception::destroy
virtual void destroy()
Definition Exception.cpp:74
Exception::toStringAll
String toStringAll() const
Definition Exception.cpp:45
Files::readBytes
static ByteString readBytes(InputStream &_input, size_t _n=(size_t) -1) __DCL_THROWS1(IOException *)
Definition Files.cpp:397
SQL::typeBinary
@ typeBinary
Definition SQLCore.h:74
SQL::typeNumeric
@ typeNumeric
Definition SQLCore.h:64
SQL::typeTime
@ typeTime
Definition SQLCore.h:66
SQL::typeLongBinary
@ typeLongBinary
Definition SQLCore.h:76
SQL::typeUInteger
@ typeUInteger
Definition SQLCore.h:62
SQL::typeTimeStamp
@ typeTimeStamp
Definition SQLCore.h:68
SQL::typeInputStream
@ typeInputStream
Definition SQLCore.h:81
SQL::typeInterval
@ typeInterval
Definition SQLCore.h:70
SQL::typeDate
@ typeDate
Definition SQLCore.h:65
SQL::typeText
@ typeText
Definition SQLCore.h:73
SQL::typeFloat
@ typeFloat
Definition SQLCore.h:63
SQL::typeInteger
@ typeInteger
Definition SQLCore.h:61
SQL::typeLongText
@ typeLongText
Definition SQLCore.h:75
SQL::eInvalidData
@ eInvalidData
Definition SQLCore.h:54
SQL::eNotSupportDataType
@ eNotSupportDataType
Definition SQLCore.h:48
SQL::eInvalidDataSize
@ eInvalidDataSize
Definition SQLCore.h:55
SQL::TimeStamp::tzoff
int16_t tzoff
Definition SQLCore.h:119

◆ conn()

PeConnection * PeParam::conn ( ) const
inlineprotected

Definition at line 57 of file PeParam.h.

58{
59 return query()->conn();
60}
PeParam::query
PeQuery * query() const
Definition PeParam.h:52

◆ init()

bool PeParam::init ( SQL::Query * _query,
sqlvar_t * _sqlvar )

Definition at line 64 of file PeParam.cpp.

65{
66 __DCL_ASSERT((Param::__queryHandle == NULL) && (__sqlvar == NULL));
67
68 Param::__queryHandle = _queryHandle;
69
70 //__DCL_TRACE4_N(L"type[%d] len[%d] data[%p] ind[%p]\n",
71 // _sqlvar->sqltype, _sqlvar->sqllen,
72 // _sqlvar->sqldata, _sqlvar->sqlind);
73
74 __sqlvar = _sqlvar;
75 //__sqlvar->sqltype = 0;
76 //__sqlvar->sqllen = 0;
77 //__sqlvar->sqldata = NULL;
78 __sqlvar->sqlind = &__indicator;
79 __indicator = -1; // set null
80
81 return true;
82}
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:394

◆ onAfterExecute()

bool PeParam::onAfterExecute ( )

Definition at line 98 of file PeParam.cpp.

99{
100 Param::__dataType = SQL::typeUnknown;
101 __sqlvar->sqltype = 0;
102 __sqlvar->sqllen = 0;
103 __sqlvar->sqldata = NULL;
104 __indicator = -1; // set null
105 __bytes.clear();
106
107 return true;
108}
SQL::typeUnknown
@ typeUnknown
Definition SQLCore.h:60

◆ query()

PeQuery * PeParam::query ( ) const
inlineprotected

Definition at line 52 of file PeParam.h.

53{
54 return (PeQuery*)Param::__queryHandle;
55}

◆ serverDataTypeName()

const wchar_t * PeParam::serverDataTypeName ( ) const
virtual

Implements SQL::Field.

Definition at line 113 of file PeParam.cpp.

114{
115 return __dataTypeName(__sqlvar);
116}
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:304

◆ setNull()

void PeParam::setNull ( )
virtual

Implements SQL::Param.

Definition at line 118 of file PeParam.cpp.

119{
120 Param::__dataType = SQL::typeUnknown;
121 __sqlvar->sqltype = 0;
122 __sqlvar->sqllen = 0;
123 __sqlvar->sqldata = NULL;
124 __indicator = -1; // set null
125}

Member Data Documentation

◆ dt

date PeParam::dt

Definition at line 20 of file PeParam.h.

◆ f32

float PeParam::f32

Definition at line 17 of file PeParam.h.

◆ f64

double PeParam::f64

Definition at line 18 of file PeParam.h.

◆ i32

int32_t PeParam::i32

Definition at line 13 of file PeParam.h.

◆ i64

int64_t PeParam::i64

Definition at line 14 of file PeParam.h.

◆ ival

interval PeParam::ival

Definition at line 22 of file PeParam.h.

◆ nu

numeric PeParam::nu

Definition at line 19 of file PeParam.h.

◆ ts

timestamp PeParam::ts

Definition at line 21 of file PeParam.h.

◆ u32

uint32_t PeParam::u32

Definition at line 15 of file PeParam.h.

◆ u64

uint64_t PeParam::u64

Definition at line 16 of file PeParam.h.

The documentation for this class was generated from the following files: