DCL 4.1
Loading...
Searching...
No Matches
PgParam Class Reference

#include <PgParam.h>

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

Public Member Functions

bool init (SQL::Query *_query, sqlvar_t *_sqlvar)
bool onAfterExecute ()
 PgParam ()
virtual ~PgParam ()
virtual const wchar_t * serverDataTypeName () const
virtual void setNull ()
virtual bool __setData (_CONST void *_pv, size_t _size, SQL::DataType _dataType, SQL::DataType _assignType)
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

void setErrorStatus (SQL::Error _error, long _SQLCODE, const wchar_t *_filename, int _line)
void setErrorStatus (const ByteString &_message, const wchar_t *_filename, int _line)
PgQuery * query () const
Protected Member Functions inherited from SQL::Param
 Param (Query *_queryHandle)
virtual ~Param ()
virtual bool isNull () const
virtual bool __setDataType (DataType _dataType)
virtual bool __getDataSize (size_t *_pn, bool _maxSize)
virtual bool __getData (void *_pv, size_t *_pn, DataType _dataType)
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 PgParam.h.

Constructor & Destructor Documentation

◆ PgParam()

PgParam::PgParam ( )

◆ ~PgParam()

PgParam::~PgParam ( )
virtual

Definition at line 53 of file PgParam.cpp.

54{
55}

Member Function Documentation

◆ __setData()

bool PgParam::__setData ( _CONST void * _pv,
size_t _size,
SQL::DataType _dataType,
SQL::DataType _assignType )
virtual

Implements SQL::Param.

Definition at line 120 of file PgParam.cpp.

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

◆ init()

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

Definition at line 57 of file PgParam.cpp.

58{
59 __DCL_ASSERT((Param::__queryHandle == NULL) && (__sqlvar == NULL));
60
61 Param::__queryHandle = _queryHandle;
62
63 //__DCL_TRACE4_N(L"type[%d] len[%d] data[%p] ind[%p]\n",
64 // _sqlvar->sqltype, _sqlvar->sqllen,
65 // _sqlvar->sqldata, _sqlvar->sqlind);
66
67 __sqlvar = _sqlvar;
68 //__sqlvar->sqltype = 0;
69 //__sqlvar->sqllen = 0;
70 //__sqlvar->sqldata = NULL;
71 __sqlvar->sqlind = &__indicator;
72 __indicator = -1; // set null
73
74 return true;
75}
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371

◆ onAfterExecute()

bool PgParam::onAfterExecute ( )

Definition at line 91 of file PgParam.cpp.

92{
93 Param::__dataType = SQL::typeUnknown;
94 __sqlvar->sqltype = 0;
95 __sqlvar->sqllen = 0;
96 __sqlvar->sqldata = NULL;
97 __indicator = -1; // set null
98 __bytes.clear();
99
100 return true;
101}
SQL::typeUnknown
@ typeUnknown
Definition SQLCore.h:63

◆ query()

PgQuery * PgParam::query ( ) const
inlineprotected

Definition at line 76 of file PgParam.h.

77{
78 return (PgQuery*)Param::__queryHandle;
79}

◆ serverDataTypeName()

const wchar_t * PgParam::serverDataTypeName ( ) const
virtual

Implements SQL::Field.

Definition at line 106 of file PgParam.cpp.

107{
108 return __dataTypeName(__sqlvar);
109}
__dataTypeName
const wchar_t * __dataTypeName(const ifx_sqlvar_t *_sqlvar)
Definition IFXField.cpp:290

◆ setErrorStatus() [1/2]

void PgParam::setErrorStatus ( const ByteString & _message,
const wchar_t * _filename,
int _line )
inlineprotected

Definition at line 66 of file PgParam.h.

68{
69 ((PgConnection*)Param::connection())->setErrorStatus(
70 _message,
71 _filename,
72 _line
73 );
74}

◆ setErrorStatus() [2/2]

void PgParam::setErrorStatus ( SQL::Error _error,
long _SQLCODE,
const wchar_t * _filename,
int _line )
inlineprotected

Definition at line 55 of file PgParam.h.

57{
58 ((PgConnection*)Param::connection())->setErrorStatus(
59 _error,
60 _SQLCODE,
61 _filename,
62 _line
63 );
64}

◆ setNull()

void PgParam::setNull ( )
virtual

Implements SQL::Param.

Definition at line 111 of file PgParam.cpp.

112{
113 Param::__dataType = SQL::typeUnknown;
114 __sqlvar->sqltype = 0;
115 __sqlvar->sqllen = 0;
116 __sqlvar->sqldata = NULL;
117 __indicator = -1; // set null
118}

Member Data Documentation

◆ dt

date PgParam::dt

Definition at line 20 of file PgParam.h.

◆ f32

float PgParam::f32

Definition at line 17 of file PgParam.h.

◆ f64

double PgParam::f64

Definition at line 18 of file PgParam.h.

◆ i32

int32_t PgParam::i32

Definition at line 13 of file PgParam.h.

◆ i64

int64_t PgParam::i64

Definition at line 14 of file PgParam.h.

◆ ival

interval PgParam::ival

Definition at line 22 of file PgParam.h.

◆ nu

numeric PgParam::nu

Definition at line 19 of file PgParam.h.

◆ ts

timestamp PgParam::ts

Definition at line 21 of file PgParam.h.

◆ u32

uint32_t PgParam::u32

Definition at line 15 of file PgParam.h.

◆ u64

uint64_t PgParam::u64

Definition at line 16 of file PgParam.h.

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