OCILIB (C and C++ Driver for Oracle)  4.4.0
ocilib_impl.hpp
1 /*
2  * OCILIB - C Driver for Oracle (C Wrapper for Oracle OCI)
3  *
4  * Website: http://www.ocilib.net
5  *
6  * Copyright (c) 2007-2017 Vincent ROGIER <vince.rogier@ocilib.net>
7  *
8  * Licensed under the Apache License, Version 2.0 (the "License");
9  * you may not use this file except in compliance with the License.
10  * You may obtain a copy of the License at
11  *
12  * http://www.apache.org/licenses/LICENSE-2.0
13  *
14  * Unless required by applicable law or agreed to in writing, software
15  * distributed under the License is distributed on an "AS IS" BASIS,
16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17  * See the License for the specific language governing permissions and
18  * limitations under the License.
19  */
20 
21 /*
22  * IMPORTANT NOTICE
23  *
24  * This C++ header defines C++ wrapper classes around the OCILIB C API
25  * It requires a compatible version of OCILIB
26  *
27  */
28 
29 #pragma once
30 
31 #include <algorithm>
32 
33 namespace ocilib
34 {
35 
36 /* ********************************************************************************************* *
37  * IMPLEMENTATION
38  * ********************************************************************************************* */
39 
50 
61 
67 template<class I, class O>
69 {
70  typedef I InputType;
71  typedef O OutputType;
72 };
73 
79 template<class T>
81 
82 template<> struct BindResolver<bool> : BindResolverType<bool, boolean>{};
83 template<> struct BindResolver<short> : BindResolverScalarType<short>{};
84 template<> struct BindResolver<unsigned short> : BindResolverScalarType<unsigned short>{};
85 template<> struct BindResolver<int> : BindResolverScalarType<int>{};
86 template<> struct BindResolver<unsigned int> : BindResolverScalarType<unsigned int>{};
87 template<> struct BindResolver<big_int> : BindResolverScalarType<big_int>{};
88 template<> struct BindResolver<big_uint> : BindResolverScalarType<big_uint>{};
89 template<> struct BindResolver<float> : BindResolverScalarType<float>{};
90 template<> struct BindResolver<double> : BindResolverScalarType<double>{};
91 template<> struct BindResolver<ostring> : BindResolverType<ostring, otext>{};
92 template<> struct BindResolver<Raw> : BindResolverType<ostring, unsigned char>{};
93 template<> struct BindResolver<Number> : BindResolverType<Number, OCI_Number*>{};
94 template<> struct BindResolver<Date> : BindResolverType<Date, OCI_Date*>{};
95 template<> struct BindResolver<Timestamp> : BindResolverType<Timestamp, OCI_Timestamp*>{};
96 template<> struct BindResolver<Interval> : BindResolverType<Interval, OCI_Interval*>{};
97 template<> struct BindResolver<Clob> : BindResolverType<Clob, OCI_Lob*>{};
98 template<> struct BindResolver<NClob> : BindResolverType<NClob, OCI_Lob*>{};
99 template<> struct BindResolver<Blob> : BindResolverType<Blob, OCI_Lob*>{};
100 template<> struct BindResolver<File> : BindResolverType<File, OCI_File*>{};
101 template<> struct BindResolver<Clong> : BindResolverType<Clong, OCI_Long*>{};
102 template<> struct BindResolver<Blong> : BindResolverType<Blong, OCI_Long*>{};
103 template<> struct BindResolver<Reference> : BindResolverType<Reference, OCI_Ref*>{};
104 template<> struct BindResolver<Object> : BindResolverType<Object, OCI_Object*>{};
105 template<> struct BindResolver<Statement> : BindResolverType<Statement, OCI_Statement*>{};
106 
110 template<class T> struct NumericTypeResolver{};
111 
112 template<> struct NumericTypeResolver<OCI_Number*> { enum { Value = NumericNumber }; };
113 template<> struct NumericTypeResolver<Number> { enum { Value = NumericNumber }; };
114 template<> struct NumericTypeResolver<short> { enum { Value = NumericShort }; };
115 template<> struct NumericTypeResolver<unsigned short> { enum { Value = NumericUnsignedShort }; };
116 template<> struct NumericTypeResolver<int> { enum { Value = NumericInt }; };
117 template<> struct NumericTypeResolver<unsigned int> { enum { Value = NumericUnsignedInt }; };
118 template<> struct NumericTypeResolver<big_int> { enum { Value = NumericBigInt }; };
119 template<> struct NumericTypeResolver<big_uint> { enum { Value = NumericUnsignedBigInt }; };
120 template<> struct NumericTypeResolver<double> { enum { Value = NumericDouble }; };
121 template<> struct NumericTypeResolver<float> { enum { Value = NumericFloat }; };
122 
123 template<class T>
124 T Check(T result)
125 {
126  OCI_Error *err = OCI_GetLastError();
127 
128  if (err)
129  {
130  throw Exception(err);
131  }
132 
133  return result;
134 }
135 
136 inline ostring MakeString(const otext *result, int size)
137 {
138  return result ? (size >= 0 ? ostring(result, result + size) : ostring(result)) : ostring();
139 }
140 
141 inline Raw MakeRaw(void *result, unsigned int size)
142 {
143  unsigned char *ptr = static_cast<unsigned char *>(result);
144 
145  return (ptr && size > 0 ? Raw(ptr, ptr + size) : Raw());
146 }
147 
148 template<class S, class C>
149 void ConverString(S &dest, const C *src, size_t length)
150 {
151  size_t i = 0;
152 
153  dest.clear();
154 
155  if (src)
156  {
157  dest.resize(length);
158 
159  while (i < length)
160  {
161  dest[i] = static_cast<typename S::value_type>(src[i]);
162 
163  ++i;
164  }
165  }
166 }
167 
168 /* --------------------------------------------------------------------------------------------- *
169  * Enum
170  * --------------------------------------------------------------------------------------------- */
171 
172 template<class T>
173 Enum<T>::Enum() : _value(0)
174 {
175 }
176 
177 template<class T>
178 Enum<T>::Enum(T value) : _value(value)
179 {
180 }
181 
182 template<class T>
184 {
185  return _value;
186 }
187 
188 template<class T>
190 {
191  return GetValue();
192 }
193 
194 template<class T>
195 Enum<T>::operator unsigned int () const
196 {
197  return static_cast<unsigned int>(_value);
198 }
199 
200 template<class T>
201 bool Enum<T>::operator == (const Enum& other) const
202 {
203  return other._value == _value;
204 }
205 
206 template<class T>
207 bool Enum<T>::operator != (const Enum& other) const
208 {
209  return !(*this == other);
210 }
211 
212 template<class T>
213 bool Enum<T>::operator == (const T& other) const
214 {
215  return other == _value;
216 }
217 
218 template<class T>
219 bool Enum<T>::operator != (const T& other) const
220 {
221  return !(*this == other);
222 }
223 
224 /* --------------------------------------------------------------------------------------------- *
225  * Flags
226  * --------------------------------------------------------------------------------------------- */
227 
228 template<class T>
229 Flags<T>::Flags() : _flags(static_cast<T>(0))
230 {
231 }
232 
233 template<class T>
234 Flags<T>::Flags(T flag) : _flags( flag)
235 {
236 }
237 
238 template<class T>
239 Flags<T>::Flags(const Flags& other) : _flags(other._flags)
240 {
241 }
242 
243 template<class T>
244 Flags<T>::Flags(unsigned int flag) : _flags(static_cast<T>(flag))
245 {
246 }
247 
248 template<class T>
250 {
251  return Flags<T>(~_flags);
252 }
253 
254 template<class T>
255 Flags<T> Flags<T>::operator | (const Flags& other) const
256 {
257  return Flags<T>(_flags | other._flags);
258 }
259 
260 template<class T>
261 Flags<T> Flags<T>::operator & (const Flags& other) const
262 {
263  return Flags<T>(_flags & other._flags);
264 }
265 
266 template<class T>
267 Flags<T> Flags<T>::operator ^ (const Flags& other) const
268 {
269  return Flags<T>(_flags ^ other._flags);
270 }
271 
272 template<class T>
273 Flags<T> Flags<T>::operator | (T other) const
274 {
275  return Flags<T>(_flags | other);
276 }
277 
278 template<class T>
279 Flags<T> Flags<T>::operator & (T other) const
280 {
281  return Flags<T>(_flags & other);
282 }
283 
284 template<class T>
285 Flags<T> Flags<T>::operator ^ (T other) const
286 {
287  return Flags<T>(_flags ^ other);
288 }
289 
290 template<class T>
292 {
293  _flags |= other._flags;
294  return *this;
295 }
296 
297 template<class T>
299 {
300  _flags &= other._flags;
301  return *this;
302 }
303 
304 template<class T>
306 {
307  _flags ^= other._flags;
308  return *this;
309 }
310 
311 template<class T>
313 {
314  _flags |= other;
315  return *this;
316 }
317 
318 template<class T>
320 {
321  _flags &= other;
322  return *this;
323 }
324 
325 template<class T>
327 {
328  _flags ^= other;
329  return *this;
330 }
331 
332 template<class T>
333 bool Flags<T>::operator == (T other) const
334 {
335  return _flags == static_cast<unsigned int>(other);
336 }
337 
338 template<class T>
339 bool Flags<T>::operator == (const Flags& other) const
340 {
341  return _flags == other._flags;
342 }
343 
344 template<class T>
345 bool Flags<T>::IsSet(T other) const
346 {
347  return ((_flags & other) == _flags);
348 }
349 
350 template<class T>
351 unsigned int Flags<T>::GetValues() const
352 {
353  return _flags;
354 }
355 
356 #define OCI_DEFINE_FLAG_OPERATORS(T) \
357 inline Flags<T> operator | (T a, T b) { return Flags<T>(a) | Flags<T>(b); } \
358 
359 OCI_DEFINE_FLAG_OPERATORS(Environment::EnvironmentFlagsValues)
360 OCI_DEFINE_FLAG_OPERATORS(Environment::SessionFlagsValues)
361 OCI_DEFINE_FLAG_OPERATORS(Environment::StartFlagsValues)
362 OCI_DEFINE_FLAG_OPERATORS(Environment::StartModeValues)
363 OCI_DEFINE_FLAG_OPERATORS(Environment::ShutdownModeValues)
364 OCI_DEFINE_FLAG_OPERATORS(Environment::ShutdownFlagsValues)
365 OCI_DEFINE_FLAG_OPERATORS(Environment::AllocatedBytesValues)
366 OCI_DEFINE_FLAG_OPERATORS(Transaction::TransactionFlagsValues)
367 OCI_DEFINE_FLAG_OPERATORS(Column::PropertyFlagsValues)
368 OCI_DEFINE_FLAG_OPERATORS(Subscription::ChangeTypesValues)
369 
370 /* --------------------------------------------------------------------------------------------- *
371  * ManagedBuffer
372  * --------------------------------------------------------------------------------------------- */
373 
374 template<typename T>
375 ManagedBuffer<T>::ManagedBuffer() : _buffer(nullptr), _size(0)
376 {
377 }
378 
379 template<typename T>
380 ManagedBuffer<T>::ManagedBuffer(T *buffer, size_t size) : _buffer(buffer), _size(size)
381 {
382 }
383 
384 template<typename T>
385 ManagedBuffer<T>::ManagedBuffer(size_t size) : _buffer(new T[size]), _size(size)
386 {
387  memset(_buffer, 0, sizeof(T) * _size);
388 }
389 template<typename T>
390 ManagedBuffer<T>::~ManagedBuffer()
391 {
392  delete [] _buffer;
393 }
394 
395 template<typename T>
396 ManagedBuffer<T>::operator T* () const
397 {
398  return _buffer;
399 }
400 
401 template<typename T>
402 ManagedBuffer<T>::operator const T* () const
403 {
404  return _buffer;
405 }
406 
407 /* --------------------------------------------------------------------------------------------- *
408  * Handle
409  * --------------------------------------------------------------------------------------------- */
410 
411 template<class T>
412 HandleHolder<T>::HandleHolder() : _smartHandle(nullptr)
413 {
414 }
415 
416 template<class T>
417 HandleHolder<T>::HandleHolder(const HandleHolder &other) : _smartHandle(nullptr)
418 {
419  Acquire(other, nullptr, nullptr, other._smartHandle ? other._smartHandle->GetParent() : nullptr);
420 }
421 
422 template<class T>
424 {
425  Release();
426 }
427 
428 template<class T>
430 {
431  Acquire(other, nullptr, nullptr, other._smartHandle ? other._smartHandle->GetParent() : nullptr);
432  return *this;
433 }
434 
435 template<class T>
436 bool HandleHolder<T>::IsNull() const
437 {
438  return (static_cast<T>(*this) == 0);
439 }
440 
441 template<class T>
443 {
444  return _smartHandle ? _smartHandle->GetHandle() : nullptr;
445 }
446 
447 template<class T>
449 {
450  return _smartHandle ? _smartHandle->GetHandle() : nullptr;
451 }
452 
453 template<class T>
455 {
456  return !IsNull();
457 }
458 
459 template<class T>
460 HandleHolder<T>::operator bool() const
461 {
462  return !IsNull();
463 }
464 
465 template<class T>
466 Handle * HandleHolder<T>::GetHandle() const
467 {
468  return static_cast<Handle *>(_smartHandle);
469 }
470 
471 template<class T>
472 void HandleHolder<T>::Acquire(T handle, HandleFreeFunc handleFreefunc, SmartHandleFreeNotifyFunc freeNotifyFunc, Handle *parent)
473 {
474  Release();
475 
476  if (handle)
477  {
478  _smartHandle = Environment::GetSmartHandle<SmartHandle*>(handle);
479 
480  if (!_smartHandle)
481  {
482  _smartHandle = new SmartHandle(this, handle, handleFreefunc, freeNotifyFunc, parent);
483  }
484  else
485  {
486  _smartHandle->Acquire(this);
487  }
488  }
489 }
490 
491 template<class T>
493 {
494  if (&other != this && _smartHandle != other._smartHandle)
495  {
496  Release();
497 
498  if (other._smartHandle)
499  {
500  other._smartHandle->Acquire(this);
501  _smartHandle = other._smartHandle;
502  }
503  }
504 }
505 
506 template<class T>
508 {
509  if (_smartHandle)
510  {
511  _smartHandle->Release(this);
512  }
513 
514  _smartHandle = nullptr;
515 }
516 
517 inline Locker::Locker() : _mutex(nullptr)
518 {
519  SetAccessMode(false);
520 }
521 
522 inline Locker::~Locker()
523 {
524  SetAccessMode(false);
525 }
526 
527 inline void Locker::SetAccessMode(bool threaded)
528 {
529  if (threaded && !_mutex)
530  {
531  _mutex = Mutex::Create();
532  }
533  else if (!threaded && _mutex)
534  {
535  Mutex::Destroy(_mutex);
536  _mutex = nullptr;
537  }
538 }
539 
540 inline void Locker::Lock() const
541 {
542  if (_mutex)
543  {
544  Mutex::Acquire(_mutex);
545  }
546 }
547 
548 inline void Locker::Unlock() const
549 {
550  if (_mutex)
551  {
552  Mutex::Release(_mutex);
553  }
554 }
555 
556 inline Lockable::Lockable() : _locker(nullptr)
557 {
558 
559 }
560 
561 inline Lockable::~Lockable()
562 {
563 
564 }
565 
566 inline void Lockable::Lock() const
567 {
568  if (_locker)
569  {
570  _locker->Lock();
571  }
572 }
573 
574 inline void Lockable::Unlock() const
575 {
576  if (_locker)
577  {
578  _locker->Unlock();
579  }
580 }
581 
582 inline void Lockable::SetLocker(Locker *locker)
583 {
584  _locker = locker;
585 }
586 
587 template<class K, class V>
588 ConcurrentMap<K, V>::ConcurrentMap()
589 {
590 
591 }
592 
593 template<class K, class V>
594 ConcurrentMap<K, V>::~ConcurrentMap()
595 {
596  Clear();
597 }
598 
599 template<class K, class V>
600 void ConcurrentMap<K, V>::Remove(K key)
601 {
602  Lock();
603  _map.erase(key);
604  Unlock();
605 }
606 
607 template<class K, class V>
608 V ConcurrentMap<K, V>::Get(K key)
609 {
610  V value = 0;
611 
612  Lock();
613  typename std::map< K, V >::const_iterator it = _map.find(key);
614  if (it != _map.end())
615  {
616  value = it->second;
617  }
618  Unlock();
619 
620  return value;
621 }
622 
623 template<class K, class V>
624 void ConcurrentMap<K, V>::Set(K key, V value)
625 {
626  Lock();
627  _map[key] = value;
628  Unlock();
629 }
630 
631 template<class K, class V>
632 void ConcurrentMap<K, V>::Clear()
633 {
634  Lock();
635  _map.clear();
636  Unlock();
637 }
638 
639 template<class K, class V>
640 size_t ConcurrentMap<K, V>::GetSize()
641 {
642  Lock();
643  size_t size = _map.size();
644  Unlock();
645 
646  return size;
647 }
648 
649 template<class T>
650 ConcurrentList<T>::ConcurrentList()
651 {
652 
653 }
654 
655 template<class T>
656 ConcurrentList<T>::~ConcurrentList()
657 {
658  Clear();
659 }
660 
661 template<class T>
662 void ConcurrentList<T>::Add(T value)
663 {
664  Lock();
665  _list.push_back(value);
666  Unlock();
667 }
668 
669 template<class T>
670 void ConcurrentList<T>::Remove(T value)
671 {
672  Lock();
673  _list.remove(value);
674  Unlock();
675 }
676 
677 template<class T>
678 void ConcurrentList<T>::Clear()
679 {
680  Lock();
681  _list.clear();
682  Unlock();
683 }
684 
685 template<class T>
686 size_t ConcurrentList<T>::GetSize()
687 {
688  Lock();
689  size_t size = _list.size();
690  Unlock();
691 
692  return size;
693 }
694 
695 template<class T>
696 bool ConcurrentList<T>::Exists(const T &value)
697 {
698  Lock();
699 
700  bool res = std::find(_list.begin(), _list.end(), value) != _list.end();
701 
702  Unlock();
703 
704  return res;
705 }
706 
707 template<class T>
708 template<class P>
709 bool ConcurrentList<T>::FindIf(P predicate, T &value)
710 {
711  bool res = false;
712 
713  Lock();
714 
715  typename std::list<T>::iterator it = std::find_if(_list.begin(), _list.end(), predicate);
716 
717  if (it != _list.end())
718  {
719  value = *it;
720  res = true;
721  }
722 
723  Unlock();
724 
725  return res;
726 }
727 
728 template<class T>
729 template<class A>
730 void ConcurrentList<T>::ForEach(A action)
731 {
732  Lock();
733 
734  std::for_each(_list.begin(), _list.end(), action);
735 
736  Unlock();
737 }
738 
739 template<class T>
741 (
742  HandleHolder *holder, T handle, HandleFreeFunc handleFreefunc,
743  SmartHandleFreeNotifyFunc freeNotifyFunc, Handle *parent
744 )
745  : _holders(), _children(), _locker(), _handle(handle), _handleFreeFunc(handleFreefunc),
746  _freeNotifyFunc(freeNotifyFunc), _parent(parent), _extraInfo(nullptr)
747 {
748  _locker.SetAccessMode((Environment::GetMode() & Environment::Threaded) == Environment::Threaded);
749 
750  _holders.SetLocker(&_locker);
751  _children.SetLocker(&_locker);
752 
753  Environment::SetSmartHandle<SmartHandle*>(handle, this);
754 
755  Acquire(holder);
756 
757  if (_parent && _handle)
758  {
759  _parent->GetChildren().Add(this);
760  }
761 }
762 
763 template<class T>
765 {
766  boolean ret = TRUE;
767  boolean chk = FALSE;
768 
769  if (_parent && _handle)
770  {
771  _parent->GetChildren().Remove(this);
772  }
773 
774  _children.ForEach(DeleteHandle);
775  _children.Clear();
776 
777  _holders.SetLocker(nullptr);
778  _children.SetLocker(nullptr);
779 
780  Environment::SetSmartHandle<SmartHandle*>(_handle, nullptr);
781 
782  if (_freeNotifyFunc)
783  {
784  _freeNotifyFunc(this);
785  }
786 
787  if (_handleFreeFunc && _handle)
788  {
789  ret = _handleFreeFunc(_handle);
790  chk = TRUE;
791  }
792 
793  if (chk)
794  {
795  Check(ret);
796  }
797 }
798 
799 template<class T>
801 {
802  if (handle)
803  {
804  handle->DetachFromParent();
805  handle->DetachFromHolders();
806 
807  delete handle;
808  }
809 }
810 
811 template<class T>
813 {
814  if (holder)
815  {
816  holder->_smartHandle = 0;
817  }
818 }
819 
820 template<class T>
822 {
823  _holders.Add(holder);
824 }
825 
826 template<class T>
828 {
829  _holders.Remove(holder);
830 
831  if (_holders.GetSize() == 0)
832  {
833  delete this;
834  }
835 
836  holder->_smartHandle = nullptr;
837 }
838 
839 template<class T>
841 {
842  return _handle;
843 }
844 
845 template<class T>
847 {
848  return _parent;
849 }
850 
851 template<class T>
853 {
854  return _extraInfo;
855 }
856 
857 template<class T>
859 {
860  _extraInfo = extraInfo;
861 }
862 
863 template<class T>
864 ConcurrentList<Handle *> & HandleHolder<T>::SmartHandle::GetChildren()
865 {
866  return _children;
867 }
868 
869 template<class T>
871 {
872  _holders.ForEach(ResetHolder);
873  _holders.Clear();
874 }
875 
876 template<class T>
878 {
879  _parent = nullptr;
880 }
881 
882 /* --------------------------------------------------------------------------------------------- *
883  * Exception
884  * --------------------------------------------------------------------------------------------- */
885 
886 inline Exception::Exception()
887  : _what(),
888  _pStatement(nullptr),
889  _pConnnection(nullptr),
890  _row(0),
891  _type(static_cast<ExceptionType::Type>(0)),
892  _errLib(0),
893  _errOracle(0)
894 {
895 
896 }
897 
898 inline Exception::~Exception() throw ()
899 {
900 
901 }
902 
903 inline Exception::Exception(OCI_Error *err)
904  : _what(),
905  _pStatement(OCI_ErrorGetStatement(err)),
906  _pConnnection(OCI_ErrorGetConnection(err)),
907  _row(OCI_ErrorGetRow(err)),
908  _type(static_cast<ExceptionType::Type>(OCI_ErrorGetType(err))),
909  _errLib(OCI_ErrorGetInternalCode(err)),
910  _errOracle(OCI_ErrorGetOCICode(err))
911 {
912  const otext *str = OCI_ErrorGetString(err);
913 
914  if (str)
915  {
916  ConverString(_what, str, ostrlen(str));
917  }
918 }
919 
920 inline const char * Exception::what() const throw()
921 {
922  return _what.c_str();
923 }
924 
925 inline ostring Exception::GetMessage() const
926 {
927  ostring message;
928 
929 #ifdef OCI_CHARSET_WIDE
930 
931  ConverString(message, _what.c_str(), _what.size());
932 
933 #else
934 
935  message = _what;
936 
937 #endif
938 
939  return message;
940 }
941 
943 {
944  return _type;
945 }
946 
948 {
949  return _errOracle;
950 }
951 
953 {
954  return _errLib;
955 }
956 
957 inline Statement Exception::GetStatement() const
958 {
959  return Statement(_pStatement, nullptr);
960 }
961 
963 {
964  return Connection(_pConnnection, nullptr);
965 }
966 
967 inline unsigned int Exception::GetRow() const
968 {
969  return _row;
970 }
971 
972 /* --------------------------------------------------------------------------------------------- *
973  * Environment
974  * --------------------------------------------------------------------------------------------- */
975 
976 inline void Environment::Initialize(EnvironmentFlags mode, const ostring& libpath)
977 {
978  GetInstance().SelfInitialize(mode, libpath);
979 }
980 
981 inline void Environment::Cleanup()
982 {
983  GetInstance().SelfCleanup();
984 }
985 
987 {
988  return GetInstance()._mode;
989 }
990 
992 {
993  return ImportMode(static_cast<ImportMode::Type>(Check(OCI_GetImportMode())));
994 }
995 
997 {
998  return CharsetMode(static_cast<CharsetMode::Type>(Check(OCI_GetCharset())));
999 }
1000 
1002 {
1003  return Check(OCI_GetAllocatedBytes(type.GetValues()));
1004 }
1005 
1007 {
1008  return GetInstance()._initialized;
1009 }
1010 
1012 {
1013  return OracleVersion(static_cast<OracleVersion::Type>(Check(OCI_GetOCICompileVersion())));
1014 }
1015 
1017 {
1018  return OracleVersion(static_cast<OracleVersion::Type>(Check(OCI_GetOCIRuntimeVersion())));
1019 }
1020 
1022 {
1023  return OCI_VER_MAJ(Check(OCI_GetOCICompileVersion()));
1024 }
1025 
1027 {
1028  return OCI_VER_MIN(Check(OCI_GetOCICompileVersion()));
1029 }
1030 
1032 {
1033  return OCI_VER_REV(Check(OCI_GetOCICompileVersion()));
1034 }
1035 
1037 {
1038  return OCI_VER_MAJ(Check(OCI_GetOCIRuntimeVersion()));
1039 }
1040 
1042 {
1043  return OCI_VER_MIN(Check(OCI_GetOCIRuntimeVersion()));
1044 }
1045 
1047 {
1048  return OCI_VER_REV(Check(OCI_GetOCIRuntimeVersion()));
1049 }
1050 
1051 inline void Environment::EnableWarnings(bool value)
1052 {
1053  OCI_EnableWarnings(static_cast<boolean>(value));
1054 }
1055 
1056 inline bool Environment::SetFormat(FormatType formatType, const ostring& format)
1057 {
1058  return Check(OCI_SetFormat(nullptr, formatType, format.c_str()) == TRUE);
1059 }
1060 
1061 inline ostring Environment::GetFormat(FormatType formatType)
1062 {
1063  return MakeString(Check(OCI_GetFormat(nullptr, formatType)));
1064 }
1065 
1066 inline void Environment::StartDatabase(const ostring& db, const ostring& user, const ostring &pwd, Environment::StartFlags startFlags,
1067  Environment::StartMode startMode, Environment::SessionFlags sessionFlags, const ostring& spfile)
1068 {
1069  Check(OCI_DatabaseStartup(db.c_str(), user.c_str(), pwd.c_str(), sessionFlags.GetValues(),
1070  startMode.GetValues(), startFlags.GetValues(), spfile.c_str() ));
1071 }
1072 
1073 inline void Environment::ShutdownDatabase(const ostring& db, const ostring& user, const ostring &pwd, Environment::ShutdownFlags shutdownFlags,
1074  Environment::ShutdownMode shutdownMode, Environment::SessionFlags sessionFlags)
1075 {
1076  Check(OCI_DatabaseShutdown(db.c_str(), user.c_str(), pwd.c_str(), sessionFlags.GetValues(),
1077  shutdownMode.GetValues(), shutdownFlags.GetValues() ));
1078 }
1079 
1080 inline void Environment::ChangeUserPassword(const ostring& db, const ostring& user, const ostring& pwd, const ostring& newPwd)
1081 {
1082  Check(OCI_SetUserPassword(db.c_str(), user.c_str(), pwd.c_str(), newPwd.c_str()));
1083 }
1084 
1085 inline void Environment::SetHAHandler(HAHandlerProc handler)
1086 {
1087  Check(OCI_SetHAHandler(static_cast<POCI_HA_HANDLER>(handler != nullptr ? Environment::HAHandler : nullptr)));
1088 
1089  Environment::SetUserCallback<HAHandlerProc>(GetEnvironmentHandle(), handler);
1090 }
1091 
1092 inline void Environment::HAHandler(OCI_Connection *pConnection, unsigned int source, unsigned int event, OCI_Timestamp *pTimestamp)
1093 {
1094  HAHandlerProc handler = Environment::GetUserCallback<HAHandlerProc>(GetEnvironmentHandle());
1095 
1096  if (handler)
1097  {
1098  Connection connection(pConnection, nullptr);
1099  Timestamp timestamp(pTimestamp, connection.GetHandle());
1100 
1101  handler(connection,
1102  HAEventSource(static_cast<HAEventSource::Type>(source)),
1103  HAEventType (static_cast<HAEventType::Type> (event)),
1104  timestamp);
1105  }
1106 }
1107 
1108 inline unsigned int Environment::TAFHandler(OCI_Connection *pConnection, unsigned int type, unsigned int event)
1109 {
1110  unsigned int res = OCI_FOC_OK;
1111 
1112  Connection::TAFHandlerProc handler = Environment::GetUserCallback<Connection::TAFHandlerProc>(Check(pConnection));
1113 
1114  if (handler)
1115  {
1116  Connection connection(pConnection, nullptr);
1117 
1118  res = handler(connection,
1119  Connection::FailoverRequest( static_cast<Connection::FailoverRequest::Type> (type)),
1120  Connection::FailoverEvent ( static_cast<Connection::FailoverEvent::Type> (event)));
1121  }
1122 
1123  return res;
1124 }
1125 
1126 inline void Environment::NotifyHandler(OCI_Event *pEvent)
1127 {
1128  Subscription::NotifyHandlerProc handler = Environment::GetUserCallback<Subscription::NotifyHandlerProc>((Check(OCI_EventGetSubscription(pEvent))));
1129 
1130  if (handler)
1131  {
1132  Event evt(pEvent);
1133  handler(evt);
1134  }
1135 }
1136 
1137 inline void Environment::NotifyHandlerAQ(OCI_Dequeue *pDequeue)
1138 {
1139  Dequeue::NotifyAQHandlerProc handler = Environment::GetUserCallback<Dequeue::NotifyAQHandlerProc>(Check(pDequeue));
1140 
1141  if (handler)
1142  {
1143  Dequeue dequeue(pDequeue);
1144  handler(dequeue);
1145  }
1146 }
1147 
1148 template<class T>
1149 T Environment::GetUserCallback(AnyPointer ptr)
1150 {
1151  return reinterpret_cast<T>(GetInstance()._callbacks.Get(ptr));
1152 }
1153 
1154 template<class T>
1155 void Environment::SetUserCallback(AnyPointer ptr, T callback)
1156 {
1157  if (callback)
1158  {
1159  GetInstance()._callbacks.Set(ptr, reinterpret_cast<CallbackPointer>(callback));
1160  }
1161  else
1162  {
1163  GetInstance()._callbacks.Remove(ptr);
1164  }
1165 }
1166 
1167 template<class T>
1168 void Environment::SetSmartHandle(AnyPointer ptr, T handle)
1169 {
1170  if (handle)
1171  {
1172  GetInstance()._handles.Set(ptr, handle);
1173  }
1174  else
1175  {
1176  GetInstance()._handles.Remove(ptr);
1177  }
1178 }
1179 
1180 template<class T>
1181 T Environment::GetSmartHandle(AnyPointer ptr)
1182 {
1183  return dynamic_cast<T>(GetInstance()._handles.Get(ptr));
1184 }
1185 
1186 inline Handle * Environment::GetEnvironmentHandle()
1187 {
1188  return GetInstance()._handle.GetHandle();
1189 }
1190 
1191 inline Environment& Environment::GetInstance()
1192 {
1193  static Environment envHandle;
1194 
1195  return envHandle;
1196 }
1197 
1198 inline Environment::Environment() : _locker(), _handle(), _handles(), _callbacks(), _mode(), _initialized(false)
1199 {
1200 
1201 }
1202 
1203 inline void Environment::SelfInitialize(EnvironmentFlags mode, const ostring& libpath)
1204 {
1205  _mode = mode;
1206 
1207  Check(OCI_Initialize(nullptr, libpath.c_str(), _mode.GetValues() | OCI_ENV_CONTEXT));
1208 
1209  _initialized = true;
1210 
1211  _locker.SetAccessMode((_mode & Environment::Threaded) == Environment::Threaded);
1212 
1213  _callbacks.SetLocker(&_locker);
1214  _handles.SetLocker(&_locker);
1215 
1216  _handle.Acquire(const_cast<AnyPointer>(Check(OCI_HandleGetEnvironment())), nullptr, nullptr, nullptr);
1217 }
1218 
1219 inline void Environment::SelfCleanup()
1220 {
1221  _locker.SetAccessMode(false);
1222 
1223  _callbacks.SetLocker(nullptr);
1224  _handles.SetLocker(nullptr);
1225 
1226  _handle.Release();
1227 
1228  if (_initialized)
1229  {
1230  Check(OCI_Cleanup());
1231  }
1232 
1233  _initialized = false;
1234 }
1235 
1236 /* --------------------------------------------------------------------------------------------- *
1237  * Mutex
1238  * --------------------------------------------------------------------------------------------- */
1239 
1241 {
1242  return Environment::GetInstance().Initialized() ? Check(OCI_MutexCreate()) : nullptr;
1243 }
1244 
1245 inline void Mutex::Destroy(MutexHandle mutex)
1246 {
1247  Check(OCI_MutexFree(mutex));
1248 }
1249 
1250 inline void Mutex::Acquire(MutexHandle mutex)
1251 {
1252  Check(OCI_MutexAcquire(mutex));
1253 }
1254 
1255 inline void Mutex::Release(MutexHandle mutex)
1256 {
1257  Check(OCI_MutexRelease(mutex));
1258 }
1259 
1260 /* --------------------------------------------------------------------------------------------- *
1261  * Thread
1262  * --------------------------------------------------------------------------------------------- */
1263 
1265 {
1266  return Check(OCI_ThreadCreate());
1267 }
1268 
1269 inline void Thread::Destroy(ThreadHandle handle)
1270 {
1271  Check(OCI_ThreadFree(handle));
1272 }
1273 
1274 inline void Thread::Run(ThreadHandle handle, ThreadProc func, AnyPointer args)
1275 {
1276  Check(OCI_ThreadRun(handle, func, args));
1277 }
1278 
1279 inline void Thread::Join(ThreadHandle handle)
1280 {
1281  Check(OCI_ThreadJoin(handle));
1282 }
1283 
1285 {
1286  return Check(OCI_HandleGetThreadID(handle));
1287 }
1288 
1289 /* --------------------------------------------------------------------------------------------- *
1290  * ThreadKey
1291  * --------------------------------------------------------------------------------------------- */
1292 
1293 inline void ThreadKey::Create(const ostring& name, ThreadKeyFreeProc freeProc)
1294 {
1295  Check(OCI_ThreadKeyCreate(name.c_str(), freeProc));
1296 }
1297 
1298 inline void ThreadKey::SetValue(const ostring& name, AnyPointer value)
1299 {
1300  Check(OCI_ThreadKeySetValue(name.c_str(), value));
1301 }
1302 
1303 inline AnyPointer ThreadKey::GetValue(const ostring& name)
1304 {
1305  return Check(OCI_ThreadKeyGetValue(name.c_str()));
1306 }
1307 
1308 /* --------------------------------------------------------------------------------------------- *
1309  * Pool
1310  * --------------------------------------------------------------------------------------------- */
1311 
1312 inline Pool::Pool()
1313 {
1314 
1315 }
1316 
1317 inline Pool::Pool(const ostring& db, const ostring& user, const ostring& pwd, Pool::PoolType poolType,
1318  unsigned int minSize, unsigned int maxSize, unsigned int increment, Environment::SessionFlags sessionFlags)
1319 {
1320  Open(db, user, pwd, poolType, minSize, maxSize, increment, sessionFlags);
1321 }
1322 
1323 inline void Pool::Open(const ostring& db, const ostring& user, const ostring& pwd, Pool::PoolType poolType,
1324  unsigned int minSize, unsigned int maxSize, unsigned int increment, Environment::SessionFlags sessionFlags)
1325 {
1326  Release();
1327 
1328  Acquire(Check(OCI_PoolCreate(db.c_str(), user.c_str(), pwd.c_str(), poolType, sessionFlags.GetValues(),
1329  minSize, maxSize, increment)), reinterpret_cast<HandleFreeFunc>(OCI_PoolFree), nullptr, Environment::GetEnvironmentHandle());
1330 }
1331 
1332 inline void Pool::Close()
1333 {
1334  Release();
1335 }
1336 
1337 inline Connection Pool::GetConnection(const ostring& sessionTag)
1338 {
1339  return Connection(Check( OCI_PoolGetConnection(*this, sessionTag.c_str())), GetHandle());
1340 }
1341 
1342 inline unsigned int Pool::GetTimeout() const
1343 {
1344  return Check( OCI_PoolGetTimeout(*this));
1345 }
1346 
1347 inline void Pool::SetTimeout(unsigned int value)
1348 {
1349  Check( OCI_PoolSetTimeout(*this, value));
1350 }
1351 
1352 inline bool Pool::GetNoWait() const
1353 {
1354  return (Check( OCI_PoolGetNoWait(*this)) == TRUE);
1355 }
1356 
1357 inline void Pool::SetNoWait(bool value)
1358 {
1359  Check( OCI_PoolSetNoWait(*this, value));
1360 }
1361 
1362 inline unsigned int Pool::GetBusyConnectionsCount() const
1363 {
1364  return Check( OCI_PoolGetBusyCount(*this));
1365 }
1366 
1367 inline unsigned int Pool::GetOpenedConnectionsCount() const
1368 {
1369  return Check( OCI_PoolGetOpenedCount(*this));
1370 }
1371 
1372 inline unsigned int Pool::GetMinSize() const
1373 {
1374  return Check( OCI_PoolGetMin(*this));
1375 }
1376 
1377 inline unsigned int Pool::GetMaxSize() const
1378 {
1379  return Check( OCI_PoolGetMax(*this));
1380 }
1381 
1382 inline unsigned int Pool::GetIncrement() const
1383 {
1384  return Check( OCI_PoolGetIncrement(*this));
1385 }
1386 
1387 inline unsigned int Pool::GetStatementCacheSize() const
1388 {
1389  return Check( OCI_PoolGetStatementCacheSize(*this));
1390 }
1391 
1392 inline void Pool::SetStatementCacheSize(unsigned int value)
1393 {
1394  Check( OCI_PoolSetStatementCacheSize(*this, value));
1395 }
1396 
1397 /* --------------------------------------------------------------------------------------------- *
1398  * Connection
1399  * --------------------------------------------------------------------------------------------- */
1400 
1402 {
1403 
1404 }
1405 
1406 inline Connection::Connection(const ostring& db, const ostring& user, const ostring& pwd, Environment::SessionFlags sessionFlags)
1407 {
1408  Open(db, user, pwd, sessionFlags);
1409 }
1410 
1411 inline Connection::Connection(OCI_Connection *con, Handle *parent)
1412 {
1413  Acquire(con, reinterpret_cast<HandleFreeFunc>(parent ? OCI_ConnectionFree : nullptr), nullptr, parent);
1414 }
1415 
1416 inline void Connection::Open(const ostring& db, const ostring& user, const ostring& pwd, Environment::SessionFlags sessionFlags)
1417 {
1418  Acquire(Check(OCI_ConnectionCreate(db.c_str(), user.c_str(), pwd.c_str(), sessionFlags.GetValues())),
1419  reinterpret_cast<HandleFreeFunc>(OCI_ConnectionFree), nullptr, Environment::GetEnvironmentHandle());
1420 }
1421 
1422 inline void Connection::Close()
1423 {
1424  Release();
1425 }
1426 
1427 inline void Connection::Commit()
1428 {
1429  Check(OCI_Commit(*this));
1430 }
1431 
1433 {
1434  Check(OCI_Rollback(*this));
1435 }
1436 
1437 inline void Connection::Break()
1438 {
1439  Check(OCI_Break(*this));
1440 }
1441 
1442 inline void Connection::SetAutoCommit(bool enabled)
1443 {
1444  Check(OCI_SetAutoCommit(*this, enabled));
1445 }
1446 
1447 inline bool Connection::GetAutoCommit() const
1448 {
1449  return (Check(OCI_GetAutoCommit(*this)) == TRUE);
1450 }
1451 
1452 inline bool Connection::IsServerAlive() const
1453 {
1454  return (Check(OCI_IsConnected(*this)) == TRUE);
1455 }
1456 
1457 inline bool Connection::PingServer() const
1458 {
1459  return( Check(OCI_Ping(*this)) == TRUE);
1460 }
1461 
1462 inline ostring Connection::GetConnectionString() const
1463 {
1464  return MakeString(Check(OCI_GetDatabase(*this)));
1465 }
1466 
1467 inline ostring Connection::GetUserName() const
1468 {
1469  return MakeString(Check(OCI_GetUserName(*this)));
1470 }
1471 
1472 inline ostring Connection::GetPassword() const
1473 {
1474  return MakeString(Check(OCI_GetPassword(*this)));
1475 }
1476 
1478 {
1479  return OracleVersion(static_cast<OracleVersion::Type>(Check(OCI_GetVersionConnection(*this))));
1480 }
1481 
1482 inline ostring Connection::GetServerVersion() const
1483 {
1484  return MakeString(Check( OCI_GetVersionServer(*this)));
1485 }
1486 
1487 inline unsigned int Connection::GetServerMajorVersion() const
1488 {
1489  return Check(OCI_GetServerMajorVersion(*this));
1490 }
1491 
1492 inline unsigned int Connection::GetServerMinorVersion() const
1493 {
1494  return Check(OCI_GetServerMinorVersion(*this));
1495 }
1496 
1497 inline unsigned int Connection::GetServerRevisionVersion() const
1498 {
1499  return Check(OCI_GetServerRevisionVersion(*this));
1500 }
1501 
1502 inline void Connection::ChangePassword(const ostring& newPwd)
1503 {
1504  Check(OCI_SetPassword(*this, newPwd.c_str()));
1505 }
1506 
1507 inline ostring Connection::GetSessionTag() const
1508 {
1509  return MakeString(Check(OCI_GetSessionTag(*this)));
1510 }
1511 
1512 inline void Connection::SetSessionTag(const ostring& tag)
1513 {
1514  Check(OCI_SetSessionTag(*this, tag.c_str()));
1515 }
1516 
1518 {
1519  return Transaction(Check(OCI_GetTransaction(*this)));
1520 }
1521 
1522 inline void Connection::SetTransaction(const Transaction &transaction)
1523 {
1524  Check(OCI_SetTransaction(*this, transaction));
1525 }
1526 
1527 inline bool Connection::SetFormat(FormatType formatType, const ostring& format)
1528 {
1529  return Check(OCI_SetFormat(*this, formatType, format.c_str()) == TRUE);
1530 }
1531 
1532 inline ostring Connection::GetFormat(FormatType formatType)
1533 {
1534  return MakeString(Check(OCI_GetFormat(*this, formatType)));
1535 }
1536 
1537 inline void Connection::EnableServerOutput(unsigned int bufsize, unsigned int arrsize, unsigned int lnsize)
1538 {
1539  Check(OCI_ServerEnableOutput(*this, bufsize, arrsize, lnsize));
1540 }
1541 
1543 {
1545 }
1546 
1547 inline bool Connection::GetServerOutput(ostring &line) const
1548 {
1549  const otext * str = Check(OCI_ServerGetOutput(*this));
1550 
1551  line = MakeString(str);
1552 
1553  return (str != nullptr);
1554 }
1555 
1556 inline void Connection::GetServerOutput(std::vector<ostring> &lines) const
1557 {
1558  const otext * str = Check(OCI_ServerGetOutput(*this));
1559 
1560  while (str)
1561  {
1562  lines.push_back(str);
1563  str = Check(OCI_ServerGetOutput(*this));
1564  }
1565 }
1566 
1567 inline void Connection::SetTrace(SessionTrace trace, const ostring& value)
1568 {
1569  Check(OCI_SetTrace(*this, trace, value.c_str()));
1570 }
1571 
1572 inline ostring Connection::GetTrace(SessionTrace trace) const
1573 {
1574  return MakeString(Check(OCI_GetTrace(*this, trace)));
1575 }
1576 
1577 inline ostring Connection::GetDatabase() const
1578 {
1579  return MakeString(Check(OCI_GetDBName(*this)));
1580 }
1581 
1582 inline ostring Connection::GetInstance() const
1583 {
1584  return Check(OCI_GetInstanceName(*this));
1585 }
1586 
1587 inline ostring Connection::GetService() const
1588 {
1589  return MakeString(Check(OCI_GetServiceName(*this)));
1590 }
1591 
1592 inline ostring Connection::GetServer() const
1593 {
1594  return Check(OCI_GetServerName(*this));
1595 }
1596 
1597 inline ostring Connection::GetDomain() const
1598 {
1599  return MakeString(Check(OCI_GetDomainName(*this)));
1600 }
1601 
1602 inline Timestamp Connection::GetInstanceStartTime() const
1603 {
1604  return Timestamp(Check(OCI_GetInstanceStartTime(*this)), GetHandle());
1605 }
1606 
1607 inline unsigned int Connection::GetStatementCacheSize() const
1608 {
1609  return Check(OCI_GetStatementCacheSize(*this));
1610 }
1611 
1612 inline void Connection::SetStatementCacheSize(unsigned int value)
1613 {
1614  Check(OCI_SetStatementCacheSize(*this, value));
1615 }
1616 
1617 inline unsigned int Connection::GetDefaultLobPrefetchSize() const
1618 {
1619  return Check(OCI_GetDefaultLobPrefetchSize(*this));
1620 }
1621 
1622 inline void Connection::SetDefaultLobPrefetchSize(unsigned int value)
1623 {
1624  Check(OCI_SetDefaultLobPrefetchSize(*this, value));
1625 }
1626 
1627 inline unsigned int Connection::GetMaxCursors() const
1628 {
1629  return Check(OCI_GetMaxCursors(*this));
1630 }
1631 
1632 inline bool Connection::IsTAFCapable() const
1633 {
1634  return (Check(OCI_IsTAFCapable(*this)) == TRUE);
1635 }
1636 
1637 inline void Connection::SetTAFHandler(TAFHandlerProc handler)
1638 {
1639  Check(OCI_SetTAFHandler(*this, static_cast<POCI_TAF_HANDLER>(handler != nullptr ? Environment::TAFHandler : nullptr)));
1640 
1641  Environment::SetUserCallback<Connection::TAFHandlerProc>(static_cast<OCI_Connection*>(*this), handler);
1642 }
1643 
1645 {
1646  return Check(OCI_GetUserData(*this));
1647 }
1648 
1650 {
1651  Check(OCI_SetUserData(*this, value));
1652 }
1653 
1654 /* --------------------------------------------------------------------------------------------- *
1655  * Transaction
1656  * --------------------------------------------------------------------------------------------- */
1657 
1658 inline Transaction::Transaction(const Connection &connection, unsigned int timeout, TransactionFlags flags, OCI_XID *pxid)
1659 {
1660  Acquire(Check(OCI_TransactionCreate(connection, timeout, flags.GetValues(), pxid)), reinterpret_cast<HandleFreeFunc>(OCI_TransactionFree), nullptr, nullptr);
1661 }
1662 
1664 {
1665  Acquire(trans, nullptr, nullptr, nullptr);
1666 }
1667 
1669 {
1670  Check(OCI_TransactionPrepare(*this));
1671 }
1672 
1673 inline void Transaction::Start()
1674 {
1675  Check(OCI_TransactionStart(*this));
1676 }
1677 
1678 inline void Transaction::Stop()
1679 {
1680  Check(OCI_TransactionStop(*this));
1681 }
1682 
1683 inline void Transaction::Resume()
1684 {
1685  Check(OCI_TransactionResume(*this));
1686 }
1687 
1688 inline void Transaction::Forget()
1689 {
1690  Check(OCI_TransactionForget(*this));
1691 }
1692 
1694 {
1695  return TransactionFlags(static_cast<TransactionFlags::Type>(Check(OCI_TransactionGetMode(*this))));
1696 }
1697 
1698 inline unsigned int Transaction::GetTimeout() const
1699 {
1700  return Check(OCI_TransactionGetTimeout(*this));
1701 }
1702 
1703 /* --------------------------------------------------------------------------------------------- *
1704 * Number
1705 * --------------------------------------------------------------------------------------------- */
1706 
1707 inline Number::Number(bool create)
1708 {
1709  if (create)
1710  {
1711  Allocate();
1712  }
1713 }
1714 
1715 inline Number::Number(OCI_Number *pNumber, Handle *parent)
1716 {
1717  Acquire(pNumber, nullptr, nullptr, parent);
1718 }
1719 
1720 inline Number::Number(const ostring& str, const ostring& format)
1721 {
1722  Allocate();
1723 
1724  FromString(str, format);
1725 }
1726 
1727 inline Number::Number(const otext* str, const otext* format)
1728 {
1729  Allocate();
1730 
1731  FromString(str, format);
1732 }
1733 
1734 inline void Number::Allocate()
1735 {
1736  Acquire(Check(OCI_NumberCreate(nullptr)), reinterpret_cast<HandleFreeFunc>(OCI_NumberFree), nullptr, nullptr);
1737 }
1738 
1739 inline void Number::FromString(const ostring& str, const ostring& format) const
1740 {
1741  Check(OCI_NumberFromText(*this, str.c_str(), format.size() > 0 ? format.c_str() : Environment::GetFormat(FormatNumeric).c_str()));
1742 }
1743 
1744 inline ostring Number::ToString(const ostring& format) const
1745 {
1746  if (!IsNull())
1747  {
1748  size_t size = OCI_SIZE_BUFFER;
1749 
1750  ManagedBuffer<otext> buffer(size + 1);
1751 
1752  Check(OCI_NumberToText(*this, format.c_str(), static_cast<int>(size), buffer));
1753 
1754  return MakeString(static_cast<const otext *>(buffer));
1755  }
1756 
1757  return OCI_STRING_NULL;
1758 }
1759 
1760 inline ostring Number::ToString() const
1761 {
1762  return ToString(Environment::GetFormat(FormatNumeric));
1763 }
1764 
1765 inline Number Number::Clone() const
1766 {
1767  Number result;
1768 
1769  result.Allocate();
1770 
1771  Check(OCI_NumberAssign(result, *this));
1772 
1773  return result;
1774 }
1775 
1776 inline int Number::Compare(const Number& other) const
1777 {
1778  return Check(OCI_NumberCompare(*this, other));
1779 }
1780 
1781 template<class T>
1782 T Number::GetValue() const
1783 {
1784  T value;
1785 
1787 
1788  return value;
1789 }
1790 
1791 template<class T>
1792 Number& Number::SetValue(const T &value)
1793 {
1794  if (IsNull())
1795  {
1796  Allocate();
1797  }
1798 
1799  Check(OCI_NumberSetValue(*this, NumericTypeResolver<T>::Value, reinterpret_cast<void*>(const_cast<T*>(&value))));
1800 
1801  return *this;
1802 }
1803 
1804 template<class T>
1805 void Number::Add(const T &value)
1806 {
1807  Check(OCI_NumberAdd(*this, NumericTypeResolver<T>::Value, reinterpret_cast<void*>(const_cast<T*>(&value))));
1808 }
1809 
1810 template<class T>
1811 void Number::Sub(const T &value)
1812 {
1813  Check(OCI_NumberSub(*this, NumericTypeResolver<T>::Value, reinterpret_cast<void*>(const_cast<T*>(&value))));
1814 }
1815 
1816 template<class T>
1817 void Number::Multiply(const T &value)
1818 {
1819  Check(OCI_NumberMultiply(*this, NumericTypeResolver<T>::Value, reinterpret_cast<void*>(const_cast<T*>(&value))));
1820 }
1821 
1822 template<class T>
1823 void Number::Divide(const T &value)
1824 {
1825  Check(OCI_NumberDivide(*this, NumericTypeResolver<T>::Value, reinterpret_cast<void*>(const_cast<T*>(&value))));
1826 }
1827 
1828 inline Number& Number::operator = (OCI_Number * &lhs)
1829 {
1830  Acquire(lhs, reinterpret_cast<HandleFreeFunc>(OCI_NumberFree), nullptr, nullptr);
1831  return *this;
1832 }
1833 
1834 template<class T>
1835 Number& Number::operator = (const T &lhs)
1836 {
1837  SetValue<T>(lhs);
1838  return *this;
1839 }
1840 
1841 template<class T>
1842 Number::operator T() const
1843 {
1844  return GetValue<T>();
1845 }
1846 
1847 template<class T>
1848 Number Number::operator + (const T &value)
1849 {
1850  Number result = Clone();
1851  result.Add(value);
1852  return result;
1853 }
1854 
1855 template<class T>
1856 Number Number::operator - (const T &value)
1857 {
1858  Number result = Clone();
1859  result.Sub(value);
1860  return result;
1861 }
1862 
1863 template<class T>
1864 Number Number::operator * (const T &value)
1865 {
1866  Number result = Clone();
1867  result.Multiply(value);
1868  return result;
1869 }
1870 
1871 template<class T>
1872 Number Number::operator / (const T &value)
1873 {
1874  Number result = Clone();
1875  result.Divide(value);
1876  return result;
1877 }
1878 
1879 template<class T>
1880 Number& Number::operator += (const T &value)
1881 {
1882  Add<T>(value);
1883  return *this;
1884 }
1885 
1886 template<class T>
1887 Number& Number::operator -= (const T &value)
1888 {
1889  Sub<T>(value);
1890  return *this;
1891 }
1892 
1893 template<class T>
1894 Number& Number::operator *= (const T &value)
1895 {
1896  Multiply<T>(value);
1897  return *this;
1898 }
1899 
1900 template<class T>
1901 Number& Number::operator /= (const T &value)
1902 {
1903  Divide<T>(value);
1904  return *this;
1905 }
1906 
1907 inline Number& Number::operator ++ ()
1908 {
1909  return *this += 1;
1910 }
1911 
1912 inline Number& Number::operator -- ()
1913 {
1914  return *this += 1;
1915 }
1916 
1917 inline Number Number::operator ++ (int)
1918 {
1919  return *this + 1;
1920 }
1921 
1922 inline Number Number::operator -- (int)
1923 {
1924  return *this - 1;
1925 }
1926 
1927 inline bool Number::operator == (const Number& other) const
1928 {
1929  return Compare(other) == 0;
1930 }
1931 
1932 inline bool Number::operator != (const Number& other) const
1933 {
1934  return !(*this == other);
1935 }
1936 
1937 inline bool Number::operator > (const Number& other) const
1938 {
1939  return Compare(other) > 0;
1940 }
1941 
1942 inline bool Number::operator < (const Number& other) const
1943 {
1944  return Compare(other) < 0;
1945 }
1946 
1947 inline bool Number::operator >= (const Number& other) const
1948 {
1949  int res = Compare(other);
1950 
1951  return res == 0 || res < 0;
1952 }
1953 
1954 inline bool Number::operator <= (const Number& other) const
1955 {
1956  int res = Compare(other);
1957 
1958  return res == 0 || res > 0;
1959 }
1960 
1961 /* --------------------------------------------------------------------------------------------- *
1962  * Date
1963  * --------------------------------------------------------------------------------------------- */
1964 
1965 inline Date::Date(bool create)
1966 {
1967  if (create)
1968  {
1969  Allocate();
1970  }
1971 }
1972 
1973 inline Date::Date(const ostring& str, const ostring& format)
1974 {
1975  Allocate();
1976 
1977  FromString(str, format);
1978 }
1979 
1980 inline Date::Date(const otext* str, const otext* format)
1981 {
1982  Allocate();
1983 
1984  FromString(str, format);
1985 }
1986 
1987 inline Date::Date(OCI_Date *pDate, Handle *parent)
1988 {
1989  Acquire(pDate, nullptr, nullptr, parent);
1990 }
1991 
1992 inline void Date::Allocate()
1993 {
1994  Acquire(Check(OCI_DateCreate(nullptr)), reinterpret_cast<HandleFreeFunc>(OCI_DateFree), nullptr, nullptr);
1995 }
1996 
1997 inline Date Date::SysDate()
1998 {
1999  Date result;
2000 
2001  result.Allocate();
2002 
2003  Check(OCI_DateSysDate(result));
2004 
2005  return result;
2006 }
2007 
2008 inline Date Date::Clone() const
2009 {
2010  Date result;
2011 
2012  result.Allocate();
2013 
2014  Check(OCI_DateAssign(result, *this));
2015 
2016  return result;
2017 }
2018 
2019 inline int Date::Compare(const Date& other) const
2020 {
2021  return Check(OCI_DateCompare(*this, other));
2022 }
2023 
2024 inline bool Date::IsValid() const
2025 {
2026  return (Check(OCI_DateCheck(*this)) == 0);
2027 }
2028 
2029 inline int Date::GetYear() const
2030 {
2031  int year = 0, month = 0, day = 0;
2032 
2033  GetDate(year, month, day);
2034 
2035  return year;
2036 }
2037 
2038 inline void Date::SetYear(int value)
2039 {
2040  int year = 0, month = 0, day = 0;
2041 
2042  GetDate(year, month, day);
2043  SetDate(value, month, day);
2044 }
2045 
2046 inline int Date::GetMonth() const
2047 {
2048  int year = 0, month = 0, day = 0;
2049 
2050  GetDate(year, month, day);
2051 
2052  return month;
2053 }
2054 
2055 inline void Date::SetMonth(int value)
2056 {
2057  int year = 0, month = 0, day = 0;
2058 
2059  GetDate(year, month, day);
2060  SetDate(year, value, day);
2061 }
2062 
2063 inline int Date::GetDay() const
2064 {
2065  int year = 0, month = 0, day = 0;
2066 
2067  GetDate(year, month, day);
2068 
2069  return day;
2070 }
2071 
2072 inline void Date::SetDay(int value)
2073 {
2074  int year = 0, month = 0, day = 0;
2075 
2076  GetDate(year, month, day);
2077  SetDate(year, month, value);
2078 }
2079 
2080 inline int Date::GetHours() const
2081 {
2082  int hour = 0, minutes = 0, seconds = 0;
2083 
2084  GetTime(hour, minutes, seconds);
2085 
2086  return hour;
2087 }
2088 
2089 inline void Date::SetHours(int value)
2090 {
2091  int hour = 0, minutes = 0, seconds = 0;
2092 
2093  GetTime(hour, minutes, seconds);
2094  SetTime(value, minutes, seconds);
2095 }
2096 
2097 inline int Date::GetMinutes() const
2098 {
2099  int hour = 0, minutes = 0, seconds = 0;
2100 
2101  GetTime(hour, minutes, seconds);
2102 
2103  return minutes;
2104 }
2105 
2106 inline void Date::SetMinutes(int value)
2107 {
2108  int hour = 0, minutes = 0, seconds = 0;
2109 
2110  GetTime(hour, minutes, seconds);
2111  SetTime(hour, value, seconds);
2112 }
2113 
2114 inline int Date::GetSeconds() const
2115 {
2116  int hour = 0, minutes = 0, seconds = 0;
2117 
2118  GetTime(hour, minutes, seconds);
2119 
2120  return seconds;
2121 }
2122 
2123 inline void Date::SetSeconds(int value)
2124 {
2125  int hour = 0, minutes = 0, seconds = 0;
2126 
2127  GetTime(hour, minutes, seconds);
2128  SetTime(hour, minutes, value);
2129 }
2130 
2131 inline int Date::DaysBetween(const Date& other) const
2132 {
2133  return Check(OCI_DateDaysBetween(*this, other));
2134 }
2135 
2136 inline void Date::SetDate(int year, int month, int day)
2137 {
2138  Check(OCI_DateSetDate(*this, year, month, day));
2139 }
2140 
2141 inline void Date::SetTime(int hour, int min, int sec)
2142 {
2143  Check(OCI_DateSetTime(*this, hour, min , sec));
2144 }
2145 
2146 inline void Date::SetDateTime(int year, int month, int day, int hour, int min, int sec)
2147 {
2148  Check(OCI_DateSetDateTime(*this, year, month, day, hour, min , sec));
2149 }
2150 
2151 inline void Date::GetDate(int &year, int &month, int &day) const
2152 {
2153  Check(OCI_DateGetDate(*this, &year, &month, &day));
2154 }
2155 
2156 inline void Date::GetTime(int &hour, int &min, int &sec) const
2157 {
2158  Check(OCI_DateGetTime(*this, &hour, &min , &sec));
2159 }
2160 
2161 inline void Date::GetDateTime(int &year, int &month, int &day, int &hour, int &min, int &sec) const
2162 {
2163  Check(OCI_DateGetDateTime(*this, &year, &month, &day, &hour, &min , &sec));
2164 }
2165 
2166 inline void Date::AddDays(int days)
2167 {
2168  Check(OCI_DateAddDays(*this, days));
2169 }
2170 
2171 inline void Date::AddMonths(int months)
2172 {
2173  OCI_DateAddMonths(*this, months);
2174 }
2175 
2176 inline Date Date::NextDay(const ostring& day) const
2177 {
2178  Date result = Clone();
2179 
2180  Check(OCI_DateNextDay(result, day.c_str()));
2181 
2182  return result;
2183 }
2184 
2185 inline Date Date::LastDay() const
2186 {
2187  Date result = Clone();
2188 
2189  Check(OCI_DateLastDay(result));
2190 
2191  return result;
2192 }
2193 
2194 inline void Date::ChangeTimeZone(const ostring& tzSrc, const ostring& tzDst)
2195 {
2196  Check(OCI_DateZoneToZone(*this, tzSrc.c_str(), tzDst.c_str()));
2197 }
2198 
2199 inline void Date::FromString(const ostring& str, const ostring& format)
2200 {
2201  Check(OCI_DateFromText(*this, str.c_str(), format.size() > 0 ? format.c_str() : Environment::GetFormat(FormatDate).c_str()));
2202 }
2203 
2204 inline ostring Date::ToString(const ostring& format) const
2205 {
2206  if (!IsNull())
2207  {
2208  size_t size = OCI_SIZE_BUFFER;
2209 
2210  ManagedBuffer<otext> buffer(size + 1);
2211 
2212  Check(OCI_DateToText(*this, format.c_str(), static_cast<int>(size), buffer));
2213 
2214  return MakeString(static_cast<const otext *>(buffer));
2215  }
2216 
2217  return OCI_STRING_NULL;
2218 }
2219 
2220 inline ostring Date::ToString() const
2221 {
2222  return ToString(Environment::GetFormat(FormatDate));
2223 }
2224 
2225 inline Date& Date::operator ++ ()
2226 {
2227  return *this += 1;
2228 }
2229 
2230 inline Date Date::operator ++ (int)
2231 {
2232  Date result = Clone();
2233 
2234  *this += 1;
2235 
2236  return result;
2237 }
2238 
2239 inline Date& Date::operator -- ()
2240 {
2241  return *this -= 1;
2242 }
2243 
2244 inline Date Date::operator -- (int)
2245 {
2246  Date result = Clone();
2247 
2248  *this -= 1;
2249 
2250  return result;
2251 }
2252 
2253 inline Date Date::operator + (int value) const
2254 {
2255  Date result = Clone();
2256  return result += value;
2257 }
2258 
2259 inline Date Date::operator - (int value) const
2260 {
2261  Date result = Clone();
2262  return result -= value;
2263 }
2264 
2265 inline Date& Date::operator += (int value)
2266 {
2267  AddDays(value);
2268  return *this;
2269 }
2270 
2271 inline Date& Date::operator -= (int value)
2272 {
2273  AddDays(-value);
2274  return *this;
2275 }
2276 
2277 inline bool Date::operator == (const Date& other) const
2278 {
2279  return Compare(other) == 0;
2280 }
2281 
2282 inline bool Date::operator != (const Date& other) const
2283 {
2284  return !(*this == other);
2285 }
2286 
2287 inline bool Date::operator > (const Date& other) const
2288 {
2289  return Compare(other) > 0;
2290 }
2291 
2292 inline bool Date::operator < (const Date& other) const
2293 {
2294  return Compare(other) < 0;
2295 }
2296 
2297 inline bool Date::operator >= (const Date& other) const
2298 {
2299  int res = Compare(other);
2300 
2301  return res == 0 || res < 0;
2302 }
2303 
2304 inline bool Date::operator <= (const Date& other) const
2305 {
2306  int res = Compare(other);
2307 
2308  return res == 0 || res > 0;
2309 }
2310 
2311 /* --------------------------------------------------------------------------------------------- *
2312  * Interval
2313  * --------------------------------------------------------------------------------------------- */
2314 
2316 {
2317 }
2318 
2320 {
2321  Acquire(Check(OCI_IntervalCreate(nullptr, type)), reinterpret_cast<HandleFreeFunc>(OCI_IntervalFree), nullptr, nullptr);
2322 }
2323 
2324 inline Interval::Interval(IntervalType type, const ostring& data)
2325 {
2326  Acquire(Check(OCI_IntervalCreate(nullptr, type)), reinterpret_cast<HandleFreeFunc>(OCI_IntervalFree), nullptr, nullptr);
2327 
2328  FromString(data);
2329 }
2330 
2331 inline Interval::Interval(OCI_Interval *pInterval, Handle *parent)
2332 {
2333  Acquire(pInterval, nullptr, nullptr, parent);
2334 }
2335 
2336 inline Interval Interval::Clone() const
2337 {
2338  Interval result(GetType());
2339 
2340  Check(OCI_IntervalAssign(result, *this));
2341 
2342  return result;
2343 }
2344 
2345 inline int Interval::Compare(const Interval& other) const
2346 {
2347  return Check(OCI_IntervalCompare(*this, other));
2348 }
2349 
2351 {
2352  return IntervalType(static_cast<IntervalType::Type>(Check(OCI_IntervalGetType(*this))));
2353 }
2354 
2355 inline bool Interval::IsValid() const
2356 {
2357  return (Check(OCI_IntervalCheck(*this)) == 0);
2358 }
2359 
2360 inline int Interval::GetYear() const
2361 {
2362  int year = 0, month = 0;
2363 
2364  GetYearMonth(year, month);
2365 
2366  return year;
2367 }
2368 
2369 inline void Interval::SetYear(int value)
2370 {
2371  int year = 0, month = 0;
2372 
2373  GetYearMonth(year, month);
2374  SetYearMonth(value, month);
2375 }
2376 
2377 inline int Interval::GetMonth() const
2378 {
2379  int year = 0, month = 0;
2380 
2381  GetYearMonth(year, month);
2382 
2383  return month;
2384 }
2385 
2386 inline void Interval::SetMonth(int value)
2387 {
2388  int year = 0, month = 0;
2389 
2390  GetYearMonth(year, month);
2391  SetYearMonth(year, value);
2392 }
2393 
2394 inline int Interval::GetDay() const
2395 {
2396  int day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2397 
2398  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2399 
2400  return day;
2401 }
2402 
2403 inline void Interval::SetDay(int value)
2404 {
2405  int day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2406 
2407  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2408  SetDaySecond(value, hour, minutes, seconds, milliseconds);
2409 }
2410 
2411 inline int Interval::GetHours() const
2412 {
2413  int day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2414 
2415  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2416 
2417  return hour;
2418 }
2419 
2420 inline void Interval::SetHours(int value)
2421 {
2422  int day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2423 
2424  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2425  SetDaySecond(day, value, minutes, seconds, milliseconds);
2426 }
2427 
2428 inline int Interval::GetMinutes() const
2429 {
2430  int day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2431 
2432  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2433 
2434  return minutes;
2435 }
2436 
2437 inline void Interval::SetMinutes(int value)
2438 {
2439  int day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2440 
2441  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2442  SetDaySecond(day, hour, value, seconds, milliseconds);
2443 }
2444 
2445 inline int Interval::GetSeconds() const
2446 {
2447  int day, hour, minutes, seconds, milliseconds;
2448 
2449  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2450 
2451  return seconds;
2452 }
2453 
2454 inline void Interval::SetSeconds(int value)
2455 {
2456  int day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2457 
2458  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2459  SetDaySecond(day, hour, minutes, value, milliseconds);
2460 }
2461 
2462 inline int Interval::GetMilliSeconds() const
2463 {
2464  int day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2465 
2466  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2467 
2468  return milliseconds;
2469 }
2470 
2471 inline void Interval::SetMilliSeconds(int value)
2472 {
2473  int day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2474 
2475  GetDaySecond(day, hour, minutes, seconds, milliseconds);
2476  SetDaySecond(day, hour, minutes, seconds, value);
2477 }
2478 
2479 inline void Interval::GetDaySecond(int &day, int &hour, int &min, int &sec, int &fsec) const
2480 {
2481  Check(OCI_IntervalGetDaySecond(*this, &day, &hour, &min, &sec, &fsec));
2482 }
2483 
2484 inline void Interval::SetDaySecond(int day, int hour, int min, int sec, int fsec)
2485 {
2486  Check(OCI_IntervalSetDaySecond(*this, day, hour, min, sec, fsec));
2487 }
2488 
2489 inline void Interval::GetYearMonth(int &year, int &month) const
2490 {
2491  Check(OCI_IntervalGetYearMonth(*this, &year, &month));
2492 }
2493 inline void Interval::SetYearMonth(int year, int month)
2494 {
2495  Check(OCI_IntervalSetYearMonth(*this, year, month));
2496 }
2497 
2498 inline void Interval::UpdateTimeZone(const ostring& timeZone)
2499 {
2500  Check(OCI_IntervalFromTimeZone(*this, timeZone.c_str()));
2501 }
2502 
2503 inline void Interval::FromString(const ostring& data)
2504 {
2505  Check(OCI_IntervalFromText(*this, data.c_str()));
2506 }
2507 
2508 inline ostring Interval::ToString(int leadingPrecision, int fractionPrecision) const
2509 {
2510  if (!IsNull())
2511  {
2512  size_t size = OCI_SIZE_BUFFER;
2513 
2514  ManagedBuffer<otext> buffer(size + 1);
2515 
2516  Check(OCI_IntervalToText(*this, leadingPrecision, fractionPrecision, static_cast<int>(size), buffer));
2517 
2518  return MakeString(static_cast<const otext *>(buffer));
2519  }
2520 
2521  return OCI_STRING_NULL;
2522 }
2523 
2524 inline ostring Interval::ToString() const
2525 {
2526  return ToString(OCI_STRING_DEFAULT_PREC, OCI_STRING_DEFAULT_PREC);
2527 }
2528 
2529 inline Interval Interval::operator + (const Interval& other) const
2530 {
2531  Interval result = Clone();
2532  return result += other;
2533 }
2534 
2535 inline Interval Interval::operator - (const Interval& other) const
2536 {
2537  Interval result = Clone();
2538  return result -= other;
2539 }
2540 
2541 inline Interval& Interval::operator += (const Interval& other)
2542 {
2543  Check(OCI_IntervalAdd(*this, other));
2544  return *this;
2545 }
2546 
2547 inline Interval& Interval::operator -= (const Interval& other)
2548 {
2549  Check(OCI_IntervalSubtract(*this, other));
2550  return *this;
2551 }
2552 
2553 inline bool Interval::operator == (const Interval& other) const
2554 {
2555  return Compare(other) == 0;
2556 }
2557 
2558 inline bool Interval::operator != (const Interval& other) const
2559 {
2560  return (!(*this == other));
2561 }
2562 
2563 inline bool Interval::operator > (const Interval& other) const
2564 {
2565  return (Compare(other) > 0);
2566 }
2567 
2568 inline bool Interval::operator < (const Interval& other) const
2569 {
2570  return (Compare(other) < 0);
2571 }
2572 
2573 inline bool Interval::operator >= (const Interval& other) const
2574 {
2575  int res = Compare(other);
2576 
2577  return (res == 0 || res < 0);
2578 }
2579 
2580 inline bool Interval::operator <= (const Interval& other) const
2581 {
2582  int res = Compare(other);
2583 
2584  return (res == 0 || res > 0);
2585 }
2586 
2587 /* --------------------------------------------------------------------------------------------- *
2588  * Timestamp
2589  * --------------------------------------------------------------------------------------------- */
2590 
2592 {
2593 }
2594 
2596 {
2597  Acquire(Check(OCI_TimestampCreate(nullptr, type)), reinterpret_cast<HandleFreeFunc>(OCI_TimestampFree), nullptr, nullptr);
2598 }
2599 
2600 inline Timestamp::Timestamp(TimestampType type, const ostring& data, const ostring& format)
2601 {
2602  Acquire(Check(OCI_TimestampCreate(nullptr, type)), reinterpret_cast<HandleFreeFunc>(OCI_TimestampFree), nullptr, nullptr);
2603  FromString(data, format);
2604 }
2605 
2606 inline Timestamp::Timestamp(OCI_Timestamp *pTimestamp, Handle *parent)
2607 {
2608  Acquire(pTimestamp, nullptr, nullptr, parent);
2609 }
2610 
2611 inline Timestamp Timestamp::Clone() const
2612 {
2613  Timestamp result(GetType());
2614 
2615  Check(OCI_TimestampAssign(result, *this));
2616 
2617  return result;
2618 }
2619 
2620 inline int Timestamp::Compare(const Timestamp& other) const
2621 {
2622  return Check(OCI_TimestampCompare(*this, other));
2623 }
2624 
2626 {
2627  return TimestampType(static_cast<TimestampType::Type>(Check(OCI_TimestampGetType(*this))));
2628 }
2629 
2630 inline void Timestamp::SetDateTime(int year, int month, int day, int hour, int min, int sec, int fsec, const ostring& timeZone)
2631 {
2632  Check(OCI_TimestampConstruct(*this, year, month, day, hour, min,sec, fsec, timeZone.c_str()));
2633 }
2634 
2635 inline void Timestamp::Convert(const Timestamp& other)
2636 {
2637  Check(OCI_TimestampConvert(*this, other));
2638 }
2639 
2640 inline bool Timestamp::IsValid() const
2641 {
2642  return (Check(OCI_TimestampCheck(*this)) == 0);
2643 }
2644 
2645 inline int Timestamp::GetYear() const
2646 {
2647  int year, month, day;
2648 
2649  GetDate(year, month, day);
2650 
2651  return year;
2652 }
2653 
2654 inline void Timestamp::SetYear(int value)
2655 {
2656  int year, month, day;
2657 
2658  GetDate(year, month, day);
2659  SetDate(value, month, day);
2660 }
2661 
2662 inline int Timestamp::GetMonth() const
2663 {
2664  int year, month, day;
2665 
2666  GetDate(year, month, day);
2667 
2668  return month;
2669 }
2670 
2671 inline void Timestamp::SetMonth(int value)
2672 {
2673  int year, month, day;
2674 
2675  GetDate(year, month, day);
2676  SetDate(year, value, day);
2677 }
2678 
2679 inline int Timestamp::GetDay() const
2680 {
2681  int year, month, day;
2682 
2683  GetDate(year, month, day);
2684 
2685  return day;
2686 }
2687 
2688 inline void Timestamp::SetDay(int value)
2689 {
2690  int year, month, day;
2691 
2692  GetDate(year, month, day);
2693  SetDate(year, month, value);
2694 }
2695 
2696 inline int Timestamp::GetHours() const
2697 {
2698  int hour, minutes, seconds, milliseconds;
2699 
2700  GetTime(hour, minutes, seconds, milliseconds);
2701 
2702  return hour;
2703 }
2704 
2705 inline void Timestamp::SetHours(int value)
2706 {
2707  int hour, minutes, seconds, milliseconds;
2708 
2709  GetTime(hour, minutes, seconds, milliseconds);
2710  SetTime(value, minutes, seconds, milliseconds);
2711 }
2712 
2713 inline int Timestamp::GetMinutes() const
2714 {
2715  int hour, minutes, seconds, milliseconds;
2716 
2717  GetTime(hour, minutes, seconds, milliseconds);
2718 
2719  return minutes;
2720 }
2721 
2722 inline void Timestamp::SetMinutes(int value)
2723 {
2724  int hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2725 
2726  GetTime(hour, minutes, seconds, milliseconds);
2727  SetTime(hour, value, seconds, milliseconds);
2728 }
2729 
2730 inline int Timestamp::GetSeconds() const
2731 {
2732  int hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2733 
2734  GetTime(hour, minutes, seconds, milliseconds);
2735 
2736  return seconds;
2737 }
2738 
2739 inline void Timestamp::SetSeconds(int value)
2740 {
2741  int hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2742 
2743  GetTime(hour, minutes, seconds, milliseconds);
2744  SetTime(hour, minutes, value, milliseconds);
2745 }
2746 
2747 inline int Timestamp::GetMilliSeconds() const
2748 {
2749  int hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2750 
2751  GetTime(hour, minutes, seconds, milliseconds);
2752 
2753  return milliseconds;
2754 }
2755 
2756 inline void Timestamp::SetMilliSeconds(int value)
2757 {
2758  int hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2759 
2760  GetTime(hour, minutes, seconds, milliseconds);
2761  SetTime(hour, minutes, seconds, value);
2762 }
2763 
2764 inline void Timestamp::GetDate(int &year, int &month, int &day) const
2765 {
2766  Check(OCI_TimestampGetDate(*this, &year, &month, &day));
2767 }
2768 
2769 inline void Timestamp::GetTime(int &hour, int &min, int &sec, int &fsec) const
2770 {
2771  Check(OCI_TimestampGetTime(*this, &hour, &min, &sec, &fsec));
2772 }
2773 
2774 inline void Timestamp::GetDateTime(int &year, int &month, int &day, int &hour, int &min, int &sec, int &fsec) const
2775 {
2776  Check(OCI_TimestampGetDateTime(*this, &year, &month, &day, &hour, &min, &sec, &fsec));
2777 }
2778 
2779 inline void Timestamp::SetDate(int year, int month, int day)
2780 {
2781  int tmpYear = 0, tmpMonth = 0, tempDay = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2782 
2783  GetDateTime(tmpYear, tmpMonth, tempDay, hour, minutes, seconds, milliseconds);
2784  SetDateTime(year, month, day, hour, minutes, seconds, milliseconds);
2785 }
2786 
2787 inline void Timestamp::SetTime(int hour, int min, int sec, int fsec)
2788 {
2789  int year = 0, month = 0, day = 0, tmpHour = 0, tmpMinutes = 0, tmpSeconds = 0, tmpMilliseconds = 0;
2790 
2791  GetDateTime(year, month, day, tmpHour, tmpMinutes, tmpSeconds, tmpMilliseconds);
2792  SetDateTime(year, month, day, hour, min, sec, fsec);
2793 }
2794 
2795 inline void Timestamp::SetTimeZone(const ostring& timeZone)
2796 {
2797  if (GetType() == WithTimeZone)
2798  {
2799  int year = 0, month = 0, day = 0, hour = 0, minutes = 0, seconds = 0, milliseconds = 0;
2800 
2801  GetDateTime(year, month, day, hour, minutes, seconds, milliseconds);
2802  SetDateTime(year, month, day, hour, minutes, seconds, milliseconds, timeZone);
2803  }
2804 }
2805 
2806 inline ostring Timestamp::GetTimeZone() const
2807 {
2808  if (GetType() != NoTimeZone)
2809  {
2810  size_t size = OCI_SIZE_BUFFER;
2811 
2812  ManagedBuffer<otext> buffer(size + 1);
2813 
2814  Check(OCI_TimestampGetTimeZoneName(*this, static_cast<int>(size), buffer) == TRUE);
2815 
2816  return MakeString(static_cast<const otext *>(buffer));
2817  }
2818 
2819  return ostring();
2820 }
2821 
2822 inline void Timestamp::GetTimeZoneOffset(int &hour, int &min) const
2823 {
2824  Check(OCI_TimestampGetTimeZoneOffset(*this, &hour, &min));
2825 }
2826 
2827 inline void Timestamp::Substract(const Timestamp &lsh, const Timestamp &rsh, Interval& result)
2828 {
2829  Check(OCI_TimestampSubtract(lsh, rsh, result));
2830 }
2831 
2833 {
2834  Timestamp result(type);
2835 
2837 
2838  return result;
2839 }
2840 
2841 inline void Timestamp::FromString(const ostring& data, const ostring& format)
2842 {
2843  Check(OCI_TimestampFromText(*this, data.c_str(), format.size() > 0 ? format.c_str() : Environment::GetFormat(FormatTimestamp).c_str()));
2844 }
2845 
2846 inline ostring Timestamp::ToString(const ostring& format, int precision = OCI_STRING_DEFAULT_PREC) const
2847 {
2848  if (!IsNull())
2849  {
2850  size_t size = OCI_SIZE_BUFFER;
2851 
2852  ManagedBuffer<otext> buffer(size + 1);
2853 
2854  Check(OCI_TimestampToText(*this, format.c_str(), static_cast<int>(size), buffer, precision));
2855 
2856  return MakeString(static_cast<const otext *>(buffer));
2857  }
2858 
2859  return OCI_STRING_NULL;
2860 }
2861 
2862 inline ostring Timestamp::ToString() const
2863 {
2864  return ToString(Environment::GetFormat(FormatTimestamp), OCI_STRING_DEFAULT_PREC);
2865 }
2866 
2867 inline Timestamp& Timestamp::operator ++ ()
2868 {
2869  return *this += 1;
2870 }
2871 
2872 inline Timestamp Timestamp::operator ++ (int)
2873 {
2874  Timestamp result = Clone();
2875 
2876  *this += 1;
2877 
2878  return result;
2879 }
2880 
2881 inline Timestamp& Timestamp::operator -- ()
2882 {
2883  return *this -= 1;
2884 }
2885 
2886 inline Timestamp Timestamp::operator -- (int)
2887 {
2888  Timestamp result = Clone();
2889 
2890  *this -= 1;
2891 
2892  return result;
2893 }
2894 
2895 inline Timestamp Timestamp::operator + (int value) const
2896 {
2897  Timestamp result = Clone();
2898  Interval interval(Interval::DaySecond);
2899  interval.SetDay(1);
2900  return result += value;
2901 }
2902 
2903 inline Timestamp Timestamp::operator - (int value) const
2904 {
2905  Timestamp result = Clone();
2906  Interval interval(Interval::DaySecond);
2907  interval.SetDay(1);
2908  return result -= value;
2909 }
2910 
2911 inline Interval Timestamp::operator - (const Timestamp& other)
2912 {
2913  Interval interval(Interval::DaySecond);
2914  Check(OCI_TimestampSubtract(*this, other, interval));
2915  return interval;
2916 }
2917 
2918 inline Timestamp Timestamp::operator + (const Interval& other) const
2919 {
2920  Timestamp result = Clone();
2921  return result += other;
2922 }
2923 
2924 inline Timestamp Timestamp::operator - (const Interval& other) const
2925 {
2926  Timestamp result = Clone();
2927  return result -= other;
2928 }
2929 
2930 inline Timestamp& Timestamp::operator += (const Interval& other)
2931 {
2932  Check(OCI_TimestampIntervalAdd(*this, other));
2933  return *this;
2934 }
2935 
2936 inline Timestamp& Timestamp::operator -= (const Interval& other)
2937 {
2938  Check(OCI_TimestampIntervalSub(*this, other));
2939  return *this;
2940 }
2941 
2942 inline Timestamp& Timestamp::operator += (int value)
2943 {
2944  Interval interval(Interval::DaySecond);
2945  interval.SetDay(value);
2946  return *this += interval;
2947 }
2948 
2949 inline Timestamp& Timestamp::operator -= (int value)
2950 {
2951  Interval interval(Interval::DaySecond);
2952  interval.SetDay(value);
2953  return *this -= interval;
2954 }
2955 
2956 inline bool Timestamp::operator == (const Timestamp& other) const
2957 {
2958  return Compare(other) == 0;
2959 }
2960 
2961 inline bool Timestamp::operator != (const Timestamp& other) const
2962 {
2963  return (!(*this == other));
2964 }
2965 
2966 inline bool Timestamp::operator > (const Timestamp& other) const
2967 {
2968  return (Compare(other) > 0);
2969 }
2970 
2971 inline bool Timestamp::operator < (const Timestamp& other) const
2972 {
2973  return (Compare(other) < 0);
2974 }
2975 
2976 inline bool Timestamp::operator >= (const Timestamp& other) const
2977 {
2978  int res = Compare(other);
2979 
2980  return (res == 0 || res < 0);
2981 }
2982 
2983 inline bool Timestamp::operator <= (const Timestamp& other) const
2984 {
2985  int res = Compare(other);
2986 
2987  return (res == 0 || res > 0);
2988 }
2989 
2990 /* --------------------------------------------------------------------------------------------- *
2991  * Lob
2992  * --------------------------------------------------------------------------------------------- */
2993 
2994 template<class T, int U>
2996 {
2997 }
2998 
2999 template<class T, int U>
3000 Lob<T, U>::Lob(const Connection &connection)
3001 {
3002  Acquire(Check(OCI_LobCreate(connection, U)), reinterpret_cast<HandleFreeFunc>(OCI_LobFree), nullptr, connection.GetHandle());
3003 }
3004 
3005 template<class T, int U>
3006 Lob<T, U>::Lob(OCI_Lob *pLob, Handle *parent)
3007 {
3008  Acquire(pLob, nullptr, nullptr, parent);
3009 }
3010 
3011 template<>
3012 inline ostring Lob<ostring, LobCharacter>::Read(unsigned int length)
3013 {
3014  ManagedBuffer<otext> buffer(length + 1);
3015 
3016  length = Check(OCI_LobRead(*this, static_cast<AnyPointer>(buffer), length));
3017 
3018  return MakeString(static_cast<const otext *>(buffer), static_cast<int>(length));
3019 }
3020 
3021 template<>
3022 inline ostring Lob<ostring, LobNationalCharacter>::Read(unsigned int length)
3023 {
3024  ManagedBuffer<otext> buffer(length + 1);
3025 
3026  length = Check(OCI_LobRead(*this, static_cast<AnyPointer>(buffer), length));
3027 
3028  return MakeString(static_cast<const otext *>(buffer), static_cast<int>(length));
3029 }
3030 
3031 template<>
3032 inline Raw Lob<Raw, LobBinary>::Read(unsigned int length)
3033 {
3034  ManagedBuffer<unsigned char> buffer(length + 1);
3035 
3036  length = Check(OCI_LobRead(*this, static_cast<AnyPointer>(buffer), length));
3037 
3038  return MakeRaw(buffer, length);
3039 }
3040 
3041 template<class T, int U>
3042 unsigned int Lob<T, U>::Write(const T& content)
3043 {
3044  unsigned int res = 0;
3045 
3046  if (content.size() > 0)
3047  {
3048  res = Check(OCI_LobWrite(*this, static_cast<AnyPointer>(const_cast<typename T::value_type *>(&content[0])), static_cast<unsigned int>(content.size())));
3049  }
3050 
3051  return res;
3052 }
3053 
3054 template<class T, int U>
3055 void Lob<T, U>::Append(const Lob& other)
3056 {
3057  Check(OCI_LobAppendLob(*this, other));
3058 }
3059 
3060 template<class T, int U>
3061 unsigned int Lob<T, U>::Append(const T& content)
3062 {
3063  unsigned int res = 0;
3064 
3065  if (content.size() > 0)
3066  {
3067  Check(OCI_LobAppend(*this, static_cast<AnyPointer>(const_cast<typename T::value_type *>(&content[0])), static_cast<unsigned int>(content.size())));
3068  }
3069 
3070  return res;
3071 }
3072 
3073 template<class T, int U>
3074 bool Lob<T, U>::Seek(SeekMode seekMode, big_uint offset)
3075 {
3076  return (Check(OCI_LobSeek(*this, offset, seekMode)) == TRUE);
3077 }
3078 
3079 template<class T, int U>
3081 {
3082  Lob result(GetConnection());
3083 
3084  Check(OCI_LobAssign(result, *this));
3085 
3086  return result;
3087 }
3088 
3089 template<class T, int U>
3090 bool Lob<T, U>::Equals(const Lob &other) const
3091 {
3092  return (Check(OCI_LobIsEqual(*this, other)) == TRUE);
3093 }
3094 
3095 template<class T, int U>
3097 {
3098  return LobType(static_cast<LobType::Type>(Check(OCI_LobGetType(*this))));
3099 }
3100 
3101 template<class T, int U>
3102 big_uint Lob<T, U>::GetOffset() const
3103 {
3104  return Check(OCI_LobGetOffset(*this));
3105 }
3106 
3107 template<class T, int U>
3108 big_uint Lob<T, U>::GetLength() const
3109 {
3110  return Check(OCI_LobGetLength(*this));
3111 }
3112 
3113 template<class T, int U>
3114 big_uint Lob<T, U>::GetMaxSize() const
3115 {
3116  return Check(OCI_LobGetMaxSize(*this));
3117 }
3118 
3119 template<class T, int U>
3120 big_uint Lob<T, U>::GetChunkSize() const
3121 {
3122  return Check(OCI_LobGetChunkSize(*this));
3123 }
3124 
3125 template<class T, int U>
3127 {
3128  return Connection(Check(OCI_LobGetConnection(*this)), nullptr);
3129 }
3130 
3131 template<class T, int U>
3132 void Lob<T, U>::Truncate(big_uint length)
3133 {
3134  Check(OCI_LobTruncate(*this, length));
3135 }
3136 
3137 template<class T, int U>
3138 big_uint Lob<T, U>::Erase(big_uint offset, big_uint length)
3139 {
3140  return Check(OCI_LobErase(*this, offset, length));
3141 }
3142 
3143 template<class T, int U>
3144 void Lob<T, U>::Copy(Lob &dest, big_uint offset, big_uint offsetDest, big_uint size) const
3145 {
3146  Check(OCI_LobCopy(dest, *this, offsetDest, offset, size));
3147 }
3148 
3149 template<class T, int U>
3151 {
3152  return (Check(OCI_LobIsTemporary(*this)) == TRUE);
3153 }
3154 
3155 template<class T, int U>
3157 {
3158  Check(OCI_LobOpen(*this, mode));
3159 }
3160 
3161 template<class T, int U>
3163 {
3164  Check(OCI_LobFlush(*this));
3165 }
3166 
3167 template<class T, int U>
3169 {
3170  Check(OCI_LobClose(*this));
3171 }
3172 
3173 template<class T, int U>
3175 {
3176  Check(OCI_LobEnableBuffering(*this, value));
3177 }
3178 
3179 template<class T, int U>
3181 {
3182  Append(other);
3183  return *this;
3184 }
3185 
3186 template<class T, int U>
3187 bool Lob<T, U>::operator == (const Lob<T, U>& other) const
3188 {
3189  return Equals(other);
3190 }
3191 
3192 template<class T, int U>
3193 bool Lob<T, U>::operator != (const Lob<T, U>& other) const
3194 {
3195  return !(*this == other);
3196 }
3197 
3198 /* --------------------------------------------------------------------------------------------- *
3199  * File
3200  * --------------------------------------------------------------------------------------------- */
3201 
3202 inline File::File()
3203 {
3204 }
3205 
3206 inline File::File(const Connection &connection)
3207 {
3208  Acquire(Check(OCI_FileCreate(connection, OCI_BFILE)), reinterpret_cast<HandleFreeFunc>(OCI_FileFree), nullptr, connection.GetHandle());
3209 }
3210 
3211 inline File::File(const Connection &connection, const ostring& directory, const ostring& name)
3212 {
3213  Acquire(Check(OCI_FileCreate(connection, OCI_BFILE)), reinterpret_cast<HandleFreeFunc>(OCI_FileFree), nullptr, connection.GetHandle());
3214 
3215  SetInfos(directory, name);
3216 }
3217 
3218 inline File::File(OCI_File *pFile, Handle *parent)
3219 {
3220  Acquire(pFile, nullptr, nullptr, parent);
3221 }
3222 
3223 inline Raw File::Read(unsigned int size)
3224 {
3225  ManagedBuffer<unsigned char> buffer(size + 1);
3226 
3227  size = Check(OCI_FileRead(*this, static_cast<AnyPointer>(buffer), size));
3228 
3229  return MakeRaw(buffer, size);
3230 }
3231 
3232 inline bool File::Seek(SeekMode seekMode, big_uint offset)
3233 {
3234  return (Check(OCI_FileSeek(*this, offset, seekMode)) == TRUE);
3235 }
3236 
3237 inline File File::Clone() const
3238 {
3239  File result(GetConnection());
3240 
3241  Check(OCI_FileAssign(result, *this));
3242 
3243  return result;
3244 }
3245 
3246 inline bool File::Equals(const File &other) const
3247 {
3248  return (Check(OCI_FileIsEqual(*this, other)) == TRUE);
3249 }
3250 
3251 inline big_uint File::GetOffset() const
3252 {
3253  return Check(OCI_FileGetOffset(*this));
3254 }
3255 
3256 inline big_uint File::GetLength() const
3257 {
3258  return Check(OCI_FileGetSize(*this));
3259 }
3260 
3262 {
3263  return Connection(Check(OCI_FileGetConnection(*this)), nullptr);
3264 }
3265 
3266 inline bool File::Exists() const
3267 {
3268  return (Check(OCI_FileExists(*this)) == TRUE);
3269 }
3270 
3271 inline void File::SetInfos(const ostring& directory, const ostring& name)
3272 {
3273  Check(OCI_FileSetName(*this, directory.c_str(), name.c_str()));
3274 }
3275 
3276 inline ostring File::GetName() const
3277 {
3278  return MakeString(Check(OCI_FileGetName(*this)));
3279 }
3280 
3281 inline ostring File::GetDirectory() const
3282 {
3283  return MakeString(Check(OCI_FileGetDirectory(*this)));
3284 }
3285 
3286 inline void File::Open()
3287 {
3288  Check(OCI_FileOpen(*this));
3289 }
3290 
3291 inline bool File::IsOpened() const
3292 {
3293  return (Check(OCI_FileIsOpen(*this)) == TRUE);
3294 }
3295 
3296 inline void File::Close()
3297 {
3298  Check(OCI_FileClose(*this));
3299 }
3300 
3301 inline bool File::operator == (const File& other) const
3302 {
3303  return Equals(other);
3304 }
3305 
3306 inline bool File::operator != (const File& other) const
3307 {
3308  return (!(*this == other));
3309 }
3310 
3311 /* --------------------------------------------------------------------------------------------- *
3312  * TypeInfo
3313  * --------------------------------------------------------------------------------------------- */
3314 
3315 inline TypeInfo::TypeInfo(const Connection &connection, const ostring& name, TypeInfoType type)
3316 {
3317  Acquire(Check(OCI_TypeInfoGet(connection, name.c_str(), type)), static_cast<HandleFreeFunc>(nullptr), nullptr, connection.GetHandle());
3318 }
3319 
3320 inline TypeInfo::TypeInfo(OCI_TypeInfo *pTypeInfo)
3321 {
3322  Acquire(pTypeInfo, nullptr, nullptr, nullptr);
3323 }
3324 
3326 {
3327  return TypeInfoType(static_cast<TypeInfoType::Type>(Check(OCI_TypeInfoGetType(*this))));
3328 }
3329 
3330 inline ostring TypeInfo::GetName() const
3331 {
3332  return Check(OCI_TypeInfoGetName(*this));
3333 }
3334 
3336 {
3337  return Connection(Check(OCI_TypeInfoGetConnection(*this)), nullptr);
3338 }
3339 
3340 inline unsigned int TypeInfo::GetColumnCount() const
3341 {
3342  return Check(OCI_TypeInfoGetColumnCount(*this));
3343 }
3344 
3345 inline Column TypeInfo::GetColumn(unsigned int index) const
3346 {
3347  return Column(Check(OCI_TypeInfoGetColumn(*this, index)), GetHandle());
3348 }
3349 
3350 /* --------------------------------------------------------------------------------------------- *
3351  * Object
3352  * --------------------------------------------------------------------------------------------- */
3353 
3355 {
3356 }
3357 
3358 inline Object::Object(const TypeInfo &typeInfo)
3359 {
3360  Connection connection = typeInfo.GetConnection();
3361  Acquire(Check(OCI_ObjectCreate(connection, typeInfo)), reinterpret_cast<HandleFreeFunc>(OCI_ObjectFree), nullptr, connection.GetHandle());
3362 }
3363 
3364 inline Object::Object(OCI_Object *pObject, Handle *parent)
3365 {
3366  Acquire(pObject, nullptr, nullptr, parent);
3367 }
3368 
3369 inline Object Object::Clone() const
3370 {
3371  Object result(GetTypeInfo());
3372 
3373  Check(OCI_ObjectAssign(result, *this));
3374 
3375  return result;
3376 }
3377 
3378 inline bool Object::IsAttributeNull(const ostring& name) const
3379 {
3380  return (Check(OCI_ObjectIsNull(*this, name.c_str())) == TRUE);
3381 }
3382 
3383 inline void Object::SetAttributeNull(const ostring& name)
3384 {
3385  Check(OCI_ObjectSetNull(*this, name.c_str()));
3386 }
3387 
3389 {
3390  return TypeInfo(Check(OCI_ObjectGetTypeInfo(*this)));
3391 }
3392 
3393 inline Reference Object::GetReference() const
3394 {
3395  TypeInfo typeInfo = GetTypeInfo();
3396  Connection connection = typeInfo.GetConnection();
3397 
3398  OCI_Ref *pRef = OCI_RefCreate(connection, typeInfo);
3399 
3400  Check(OCI_ObjectGetSelfRef(*this, pRef));
3401 
3402  return Reference(pRef, GetHandle());
3403 }
3404 
3406 {
3407  return ObjectType(static_cast<ObjectType::Type>(Check(OCI_ObjectGetType(*this))));
3408 }
3409 
3410 template<>
3411 inline bool Object::Get<bool>(const ostring& name) const
3412 {
3413  return (Check(OCI_ObjectGetBoolean(*this, name.c_str())) == TRUE);
3414 }
3415 
3416 template<>
3417 inline short Object::Get<short>(const ostring& name) const
3418 {
3419  return Check(OCI_ObjectGetShort(*this, name.c_str()));
3420 }
3421 
3422 template<>
3423 inline unsigned short Object::Get<unsigned short>(const ostring& name) const
3424 {
3425  return Check(OCI_ObjectGetUnsignedShort(*this, name.c_str()));
3426 }
3427 
3428 template<>
3429 inline int Object::Get<int>(const ostring& name) const
3430 {
3431  return Check(OCI_ObjectGetInt(*this, name.c_str()));
3432 }
3433 
3434 template<>
3435 inline unsigned int Object::Get<unsigned int>(const ostring& name) const
3436 {
3437  return Check(OCI_ObjectGetUnsignedInt(*this, name.c_str()));
3438 }
3439 
3440 template<>
3441 inline big_int Object::Get<big_int>(const ostring& name) const
3442 {
3443  return Check(OCI_ObjectGetBigInt(*this, name.c_str()));
3444 }
3445 
3446 template<>
3447 inline big_uint Object::Get<big_uint>(const ostring& name) const
3448 {
3449  return Check(OCI_ObjectGetUnsignedBigInt(*this, name.c_str()));
3450 }
3451 
3452 template<>
3453 inline float Object::Get<float>(const ostring& name) const
3454 {
3455  return Check(OCI_ObjectGetFloat(*this, name.c_str()));
3456 }
3457 
3458 template<>
3459 inline double Object::Get<double>(const ostring& name) const
3460 {
3461  return Check(OCI_ObjectGetDouble(*this, name.c_str()));
3462 }
3463 
3464 template<>
3465 inline Number Object::Get<Number>(const ostring& name) const
3466 {
3467  return Number(Check(OCI_ObjectGetNumber(*this, name.c_str())), GetHandle());
3468 }
3469 
3470 template<>
3471 inline ostring Object::Get<ostring>(const ostring& name) const
3472 {
3473  return MakeString(Check(OCI_ObjectGetString(*this,name.c_str())));
3474 }
3475 
3476 template<>
3477 inline Date Object::Get<Date>(const ostring& name) const
3478 {
3479  return Date(Check(OCI_ObjectGetDate(*this,name.c_str())), GetHandle());
3480 }
3481 
3482 template<>
3483 inline Timestamp Object::Get<Timestamp>(const ostring& name) const
3484 {
3485  return Timestamp(Check(OCI_ObjectGetTimestamp(*this,name.c_str())), GetHandle());
3486 }
3487 
3488 template<>
3489 inline Interval Object::Get<Interval>(const ostring& name) const
3490 {
3491  return Interval(Check(OCI_ObjectGetInterval(*this,name.c_str())), GetHandle());
3492 }
3493 
3494 template<>
3495 inline Object Object::Get<Object>(const ostring& name) const
3496 {
3497  return Object(Check(OCI_ObjectGetObject(*this,name.c_str())), GetHandle());
3498 }
3499 
3500 template<>
3501 inline Reference Object::Get<Reference>(const ostring& name) const
3502 {
3503  return Reference(Check(OCI_ObjectGetRef(*this,name.c_str())), GetHandle());
3504 }
3505 
3506 template<>
3507 inline Clob Object::Get<Clob>(const ostring& name) const
3508 {
3509  return Clob(Check(OCI_ObjectGetLob(*this,name.c_str())), GetHandle());
3510 }
3511 
3512 template<>
3513 inline NClob Object::Get<NClob>(const ostring& name) const
3514 {
3515  return NClob(Check(OCI_ObjectGetLob(*this, name.c_str())), GetHandle());
3516 }
3517 
3518 template<>
3519 inline Blob Object::Get<Blob>(const ostring& name) const
3520 {
3521  return Blob(Check(OCI_ObjectGetLob(*this,name.c_str())), GetHandle());
3522 }
3523 
3524 template<>
3525 inline File Object::Get<File>(const ostring& name) const
3526 {
3527  return File(Check(OCI_ObjectGetFile(*this,name.c_str())), GetHandle());
3528 }
3529 
3530 template<>
3531 inline Raw Object::Get<Raw>(const ostring& name) const
3532 {
3533  unsigned int size = Check(OCI_ObjectGetRawSize(*this, name.c_str()));
3534 
3535  ManagedBuffer<unsigned char> buffer(size + 1);
3536 
3537  size = static_cast<unsigned int>(Check(OCI_ObjectGetRaw(*this, name.c_str(), static_cast<AnyPointer>(buffer), size)));
3538 
3539  return MakeRaw(buffer, size);
3540 }
3541 
3542 template<class T>
3543 T Object::Get(const ostring& name) const
3544 {
3545  return T(Check(OCI_ObjectGetColl(*this, name.c_str())), GetHandle());
3546 }
3547 
3548 template<>
3549 inline void Object::Set<bool>(const ostring& name, const bool &value)
3550 {
3551  Check(OCI_ObjectSetBoolean(*this, name.c_str(), static_cast<boolean>(value)));
3552 }
3553 
3554 template<>
3555 inline void Object::Set<short>(const ostring& name, const short &value)
3556 {
3557  Check(OCI_ObjectSetShort(*this, name.c_str(), value));
3558 }
3559 
3560 template<>
3561 inline void Object::Set<unsigned short>(const ostring& name, const unsigned short &value)
3562 {
3563  Check(OCI_ObjectSetUnsignedShort(*this, name.c_str(), value));
3564 }
3565 
3566 template<>
3567 inline void Object::Set<int>(const ostring& name, const int &value)
3568 {
3569  Check(OCI_ObjectSetInt(*this, name.c_str(), value));
3570 }
3571 
3572 template<>
3573 inline void Object::Set<unsigned int>(const ostring& name, const unsigned int &value)
3574 {
3575  Check(OCI_ObjectSetUnsignedInt(*this, name.c_str(), value));
3576 }
3577 
3578 template<>
3579 inline void Object::Set<big_int>(const ostring& name, const big_int &value)
3580 {
3581  Check(OCI_ObjectSetBigInt(*this, name.c_str(), value));
3582 }
3583 
3584 template<>
3585 inline void Object::Set<big_uint>(const ostring& name, const big_uint &value)
3586 {
3587  Check(OCI_ObjectSetUnsignedBigInt(*this, name.c_str(), value));
3588 }
3589 
3590 template<>
3591 inline void Object::Set<float>(const ostring& name, const float &value)
3592 {
3593  Check(OCI_ObjectSetFloat(*this, name.c_str(), value));
3594 }
3595 
3596 template<>
3597 inline void Object::Set<double>(const ostring& name, const double &value)
3598 {
3599  Check(OCI_ObjectSetDouble(*this, name.c_str(), value));
3600 }
3601 
3602 template<>
3603 inline void Object::Set<Number>(const ostring& name, const Number &value)
3604 {
3605  Check(OCI_ObjectSetNumber(*this, name.c_str(), value));
3606 }
3607 
3608 template<>
3609 inline void Object::Set<ostring>(const ostring& name, const ostring &value)
3610 {
3611  Check(OCI_ObjectSetString(*this, name.c_str(), value.c_str()));
3612 }
3613 
3614 template<>
3615 inline void Object::Set<Date>(const ostring& name, const Date &value)
3616 {
3617  Check(OCI_ObjectSetDate(*this, name.c_str(), value));
3618 }
3619 
3620 template<>
3621 inline void Object::Set<Timestamp>(const ostring& name, const Timestamp &value)
3622 {
3623  Check(OCI_ObjectSetTimestamp(*this, name.c_str(), value));
3624 }
3625 
3626 template<>
3627 inline void Object::Set<Interval>(const ostring& name, const Interval &value)
3628 {
3629  Check(OCI_ObjectSetInterval(*this, name.c_str(), value));
3630 }
3631 
3632 template<>
3633 inline void Object::Set<Object>(const ostring& name, const Object &value)
3634 {
3635  Check(OCI_ObjectSetObject(*this, name.c_str(), value));
3636 }
3637 
3638 template<>
3639 inline void Object::Set<Reference>(const ostring& name, const Reference &value)
3640 {
3641  Check(OCI_ObjectSetRef(*this, name.c_str(), value));
3642 }
3643 
3644 template<>
3645 inline void Object::Set<Clob>(const ostring& name, const Clob &value)
3646 {
3647  Check(OCI_ObjectSetLob(*this, name.c_str(), value));
3648 }
3649 
3650 template<>
3651 inline void Object::Set<NClob>(const ostring& name, const NClob &value)
3652 {
3653  Check(OCI_ObjectSetLob(*this, name.c_str(), value));
3654 }
3655 
3656 template<>
3657 inline void Object::Set<Blob>(const ostring& name, const Blob &value)
3658 {
3659  Check(OCI_ObjectSetLob(*this, name.c_str(), value));
3660 }
3661 
3662 template<>
3663 inline void Object::Set<File>(const ostring& name, const File &value)
3664 {
3665  Check(OCI_ObjectSetFile(*this, name.c_str(), value));
3666 }
3667 
3668 template<>
3669 inline void Object::Set<Raw>(const ostring& name, const Raw &value)
3670 {
3671  if (value.size() > 0)
3672  {
3673  Check(OCI_ObjectSetRaw(*this, name.c_str(), static_cast<AnyPointer>(const_cast<Raw::value_type *>(&value[0])), static_cast<unsigned int>(value.size())));
3674  }
3675  else
3676  {
3677  Check(OCI_ObjectSetRaw(*this, name.c_str(), nullptr, 0));
3678  }
3679 }
3680 
3681 template<class T>
3682 void Object::Set(const ostring& name, const T &value)
3683 {
3684  Check(OCI_ObjectSetColl(*this, name.c_str(), value));
3685 }
3686 
3687 inline ostring Object::ToString() const
3688 {
3689  if (!IsNull())
3690  {
3691  unsigned int len = 0;
3692 
3693  Check(OCI_ObjectToText(*this, &len, nullptr));
3694 
3695  ManagedBuffer<otext> buffer(len + 1);
3696 
3697  Check(OCI_ObjectToText(*this, &len, buffer));
3698 
3699  return MakeString(static_cast<const otext *>(buffer), static_cast<int>(len));
3700  }
3701 
3702  return OCI_STRING_NULL;
3703 }
3704 
3705 /* --------------------------------------------------------------------------------------------- *
3706  * Reference
3707  * --------------------------------------------------------------------------------------------- */
3708 
3710 {
3711 }
3712 
3713 inline Reference::Reference(const TypeInfo &typeInfo)
3714 {
3715  Connection connection = typeInfo.GetConnection();
3716  Acquire(Check(OCI_RefCreate(connection, typeInfo)), reinterpret_cast<HandleFreeFunc>(OCI_RefFree), nullptr, connection.GetHandle());
3717 }
3718 
3719 inline Reference::Reference(OCI_Ref *pRef, Handle *parent)
3720 {
3721  Acquire(pRef, nullptr, nullptr, parent);
3722 }
3723 
3725 {
3726  return TypeInfo(Check(OCI_RefGetTypeInfo(*this)));
3727 }
3728 
3729 inline Object Reference::GetObject() const
3730 {
3731  return Object(Check(OCI_RefGetObject(*this)), GetHandle());
3732 }
3733 
3734 inline Reference Reference::Clone() const
3735 {
3736  Reference result(GetTypeInfo());
3737 
3738  Check(OCI_RefAssign(result, *this));
3739 
3740  return result;
3741 }
3742 
3743 inline bool Reference::IsReferenceNull() const
3744 {
3745  return (Check(OCI_RefIsNull(*this)) == TRUE);
3746 }
3747 
3749 {
3750  Check(OCI_RefSetNull(*this));
3751 }
3752 
3753 inline ostring Reference::ToString() const
3754 {
3755  if (!IsNull())
3756  {
3757  unsigned int size = Check(OCI_RefGetHexSize(*this));
3758 
3759  ManagedBuffer<otext> buffer(size + 1);
3760 
3761  Check(OCI_RefToText(*this, size, buffer));
3762 
3763  return MakeString(static_cast<const otext *>(buffer), static_cast<int>(size));
3764  }
3765 
3766  return OCI_STRING_NULL;
3767 }
3768 
3769 /* --------------------------------------------------------------------------------------------- *
3770  * Collection
3771  * --------------------------------------------------------------------------------------------- */
3772 
3773 template<class T>
3775 {
3776 }
3777 
3778 template<class T>
3780 {
3781  Acquire(Check(OCI_CollCreate(typeInfo)), reinterpret_cast<HandleFreeFunc>(OCI_CollFree), nullptr, typeInfo.GetConnection().GetHandle());
3782 }
3783 
3784 template<class T>
3785 Collection<T>::Collection(OCI_Coll *pColl, Handle *parent)
3786 {
3787  Acquire(pColl, nullptr, nullptr, parent);
3788 }
3789 
3790 template<class T>
3792 {
3793  Collection<T> result(GetTypeInfo());
3794 
3795  Check(OCI_CollAssign(result, *this));
3796 
3797  return result;
3798 }
3799 
3800 template<class T>
3802 {
3803  return TypeInfo(Check(OCI_CollGetTypeInfo(*this)));
3804 }
3805 
3806 template<class T>
3808 {
3809  return CollectionType(Check(OCI_CollGetType(*this)));
3810 }
3811 
3812 template<class T>
3813 unsigned int Collection<T>::GetMax() const
3814 {
3815  return Check(OCI_CollGetMax(*this));
3816 }
3817 
3818 template<class T>
3819 unsigned int Collection<T>::GetSize() const
3820 
3821 {
3822  return Check(OCI_CollGetSize(*this));
3823 }
3824 
3825 template<class T>
3826 unsigned int Collection<T>::GetCount() const
3827 
3828 {
3829  return Check(OCI_CollGetCount(*this));
3830 }
3831 
3832 template<class T>
3833 void Collection<T>::Truncate(unsigned int size)
3834 {
3835  Check(OCI_CollTrim(*this, size));
3836 }
3837 
3838 template<class T>
3840 {
3841  Check(OCI_CollClear(*this));
3842 }
3843 
3844 template<class T>
3845 bool Collection<T>::IsElementNull(unsigned int index) const
3846 {
3847  return (Check(OCI_ElemIsNull(Check(OCI_CollGetElem(*this, index)))) == TRUE);
3848 }
3849 
3850 template<class T>
3851 void Collection<T>::SetElementNull(unsigned int index)
3852 {
3853  Check(OCI_ElemSetNull(Check(OCI_CollGetElem(*this, index))));
3854 }
3855 
3856 template<class T>
3857 bool Collection<T>::Delete(unsigned int index) const
3858 {
3859  return (Check(OCI_CollDeleteElem(*this, index)) == TRUE);
3860 }
3861 
3862 template<class T>
3864 {
3865  return iterator(this, 1);
3866 }
3867 
3868 template<class T>
3870 {
3871  return const_iterator(const_cast<Collection*>(this), 1);
3872 }
3873 
3874 template<class T>
3876 {
3877  return iterator(const_cast<Collection*>(this), GetCount() + 1);
3878 }
3879 
3880 template<class T>
3882 {
3883  return const_iterator(const_cast<Collection*>(this), GetCount() + 1);
3884 }
3885 
3886 template<class T>
3887 T Collection<T>::Get(unsigned int index) const
3888 {
3889  return GetElem(Check(OCI_CollGetElem(*this, index)), GetHandle());
3890 }
3891 
3892 template<class T>
3893 void Collection<T>::Set(unsigned int index, const T &data)
3894 {
3895  OCI_Elem * elem = Check(OCI_CollGetElem(*this, index));
3896 
3897  SetElem(elem, data);
3898 
3899  Check(OCI_CollSetElem(*this, index, elem));
3900 }
3901 
3902 template<class T>
3903 void Collection<T>::Append(const T &value)
3904 {
3906 
3907  SetElem(elem, value);
3908 
3909  Check(OCI_CollAppend(*this, elem));
3910  Check(OCI_ElemFree(elem));
3911 }
3912 
3913 template<>
3914 inline bool Collection<bool>::GetElem(OCI_Elem *elem, Handle *parent)
3915 {
3916  ARG_NOT_USED(parent);
3917 
3918  return (Check(OCI_ElemGetBoolean(elem)) == TRUE);
3919 }
3920 
3921 template<>
3922 inline short Collection<short>::GetElem(OCI_Elem *elem, Handle *parent)
3923 {
3924  ARG_NOT_USED(parent);
3925 
3926  return Check(OCI_ElemGetShort(elem));
3927 }
3928 
3929 template<>
3930 inline unsigned short Collection<unsigned short>::GetElem(OCI_Elem *elem, Handle *parent)
3931 {
3932  ARG_NOT_USED(parent);
3933 
3934  return Check(OCI_ElemGetUnsignedShort(elem));
3935 }
3936 
3937 template<>
3938 inline int Collection<int>::GetElem(OCI_Elem *elem, Handle *parent)
3939 {
3940  ARG_NOT_USED(parent);
3941 
3942  return Check(OCI_ElemGetInt(elem));
3943 }
3944 
3945 template<>
3946 inline unsigned int Collection<unsigned int>::GetElem(OCI_Elem *elem, Handle *parent)
3947 {
3948  ARG_NOT_USED(parent);
3949 
3950  return Check(OCI_ElemGetUnsignedInt(elem));
3951 }
3952 
3953 template<>
3954 inline big_int Collection<big_int>::GetElem(OCI_Elem *elem, Handle *parent)
3955 {
3956  ARG_NOT_USED(parent);
3957 
3958  return Check(OCI_ElemGetBigInt(elem));
3959 }
3960 
3961 template<>
3962 inline big_uint Collection<big_uint>::GetElem(OCI_Elem *elem, Handle *parent)
3963 {
3964  ARG_NOT_USED(parent);
3965 
3966  return Check(OCI_ElemGetUnsignedBigInt(elem));
3967 }
3968 
3969 template<>
3970 inline float Collection<float>::GetElem(OCI_Elem *elem, Handle *parent)
3971 {
3972  ARG_NOT_USED(parent);
3973 
3974  return Check(OCI_ElemGetFloat(elem));
3975 }
3976 
3977 template<>
3978 inline double Collection<double>::GetElem(OCI_Elem *elem, Handle *parent)
3979 {
3980  ARG_NOT_USED(parent);
3981 
3982  return Check(OCI_ElemGetDouble(elem));
3983 }
3984 
3985 template<>
3986 inline Number Collection<Number>::GetElem(OCI_Elem *elem, Handle *parent)
3987 {
3988  return Number(Check(OCI_ElemGetNumber(elem)), parent);
3989 }
3990 
3991 template<>
3992 inline ostring Collection<ostring>::GetElem(OCI_Elem *elem, Handle *parent)
3993 {
3994  ARG_NOT_USED(parent);
3995 
3996  return MakeString(Check(OCI_ElemGetString(elem)));
3997 }
3998 
3999 template<>
4000 inline Raw Collection<Raw>::GetElem(OCI_Elem *elem, Handle *parent)
4001 {
4002  ARG_NOT_USED(parent);
4003 
4004  unsigned int size = Check(OCI_ElemGetRawSize(elem));
4005 
4006  ManagedBuffer<unsigned char> buffer(size + 1);
4007 
4008  size = Check(OCI_ElemGetRaw(elem, static_cast<AnyPointer>(buffer), size));
4009 
4010  return MakeRaw(buffer, size);
4011 }
4012 
4013 template<>
4014 inline Date Collection<Date>::GetElem(OCI_Elem *elem, Handle *parent)
4015 {
4016  return Date(Check(OCI_ElemGetDate(elem)), parent);
4017 }
4018 
4019 template<>
4020 inline Timestamp Collection<Timestamp>::GetElem(OCI_Elem *elem, Handle *parent)
4021 {
4022  return Timestamp(Check(OCI_ElemGetTimestamp(elem)), parent);
4023 }
4024 
4025 template<>
4026 inline Interval Collection<Interval>::GetElem(OCI_Elem *elem, Handle *parent)
4027 {
4028  return Interval(Check(OCI_ElemGetInterval(elem)), parent);
4029 }
4030 
4031 template<>
4032 inline Object Collection<Object>::GetElem(OCI_Elem *elem, Handle *parent)
4033 {
4034  return Object(Check(OCI_ElemGetObject(elem)), parent);
4035 }
4036 
4037 template<>
4038 inline Reference Collection<Reference>::GetElem(OCI_Elem *elem, Handle *parent)
4039 {
4040  return Reference(Check(OCI_ElemGetRef(elem)), parent);
4041 }
4042 
4043 template<>
4044 inline Clob Collection<Clob>::GetElem(OCI_Elem *elem, Handle *parent)
4045 {
4046  return Clob(Check(OCI_ElemGetLob(elem)), parent);
4047 }
4048 
4049 template<>
4050 inline NClob Collection<NClob>::GetElem(OCI_Elem *elem, Handle *parent)
4051 {
4052  return NClob(Check(OCI_ElemGetLob(elem)), parent);
4053 }
4054 template<>
4055 inline Blob Collection<Blob>::GetElem(OCI_Elem *elem, Handle *parent)
4056 {
4057  return Blob(Check(OCI_ElemGetLob(elem)), parent);
4058 }
4059 
4060 template<>
4061 inline File Collection<File>::GetElem(OCI_Elem *elem, Handle *parent)
4062 {
4063  return File(Check(OCI_ElemGetFile(elem)), parent);
4064 }
4065 
4066 template<class T>
4067  T Collection<T>::GetElem(OCI_Elem *elem, Handle *parent)
4068 {
4069  return T(Check(OCI_ElemGetColl(elem)), parent);
4070 }
4071 
4072 template<>
4073 inline void Collection<bool>::SetElem(OCI_Elem *elem, const bool &value)
4074 {
4075  Check(OCI_ElemSetBoolean(elem, static_cast<boolean>(value)));
4076 }
4077 
4078 template<>
4079 inline void Collection<short>::SetElem(OCI_Elem *elem, const short &value)
4080 {
4081  Check(OCI_ElemSetShort(elem, value));
4082 }
4083 
4084 template<>
4085 inline void Collection<unsigned short>::SetElem(OCI_Elem *elem, const unsigned short &value)
4086 {
4087  Check(OCI_ElemSetUnsignedShort(elem, value));
4088 }
4089 
4090 template<>
4091 inline void Collection<int>::SetElem(OCI_Elem *elem, const int &value)
4092 {
4093  Check(OCI_ElemSetInt(elem, value));
4094 }
4095 
4096 template<>
4097 inline void Collection<unsigned int>::SetElem(OCI_Elem *elem, const unsigned int &value)
4098 {
4099  Check(OCI_ElemSetUnsignedInt(elem, value));
4100 }
4101 
4102 template<>
4103 inline void Collection<big_int>::SetElem(OCI_Elem *elem, const big_int &value)
4104 {
4105  Check(OCI_ElemSetBigInt(elem, value));
4106 }
4107 
4108 template<>
4109 inline void Collection<big_uint>::SetElem(OCI_Elem *elem, const big_uint &value)
4110 {
4111  Check(OCI_ElemSetUnsignedBigInt(elem, value));
4112 }
4113 
4114 template<>
4115 inline void Collection<float>::SetElem(OCI_Elem *elem, const float &value)
4116 {
4117  Check(OCI_ElemSetFloat(elem, value));
4118 }
4119 
4120 template<>
4121 inline void Collection<double>::SetElem(OCI_Elem *elem, const double &value)
4122 {
4123  Check(OCI_ElemSetDouble(elem, value));
4124 }
4125 
4126 template<>
4127 inline void Collection<Number>::SetElem(OCI_Elem *elem, const Number &value)
4128 {
4129  Check(OCI_ElemSetNumber(elem, value));
4130 }
4131 
4132 template<>
4133 inline void Collection<ostring>::SetElem(OCI_Elem *elem, const ostring& value)
4134 {
4135  Check(OCI_ElemSetString(elem, value.c_str()));
4136 }
4137 
4138 template<>
4139 inline void Collection<Raw>::SetElem(OCI_Elem *elem, const Raw &value)
4140 {
4141  if (value.size() > 0)
4142  {
4143  Check(OCI_ElemSetRaw(elem, static_cast<AnyPointer>(const_cast<Raw::value_type *>(&value[0])), static_cast<unsigned int>(value.size())));
4144  }
4145  else
4146  {
4147  Check(OCI_ElemSetRaw(elem, nullptr, 0));
4148  }
4149 }
4150 
4151 template<>
4152 inline void Collection<Date>::SetElem(OCI_Elem *elem, const Date &value)
4153 {
4154  Check(OCI_ElemSetDate(elem, value));
4155 }
4156 
4157 template<>
4158 inline void Collection<Timestamp>::SetElem(OCI_Elem *elem, const Timestamp &value)
4159 {
4160  Check(OCI_ElemSetTimestamp(elem, value));
4161 }
4162 
4163 template<>
4164 inline void Collection<Interval>::SetElem(OCI_Elem *elem, const Interval &value)
4165 {
4166  Check(OCI_ElemSetInterval(elem, value));
4167 }
4168 
4169 template<>
4170 inline void Collection<Object>::SetElem(OCI_Elem *elem, const Object &value)
4171 {
4172  Check(OCI_ElemSetObject(elem, value));
4173 }
4174 
4175 template<>
4176 inline void Collection<Reference>::SetElem(OCI_Elem *elem, const Reference &value)
4177 {
4178  Check(OCI_ElemSetRef(elem, value));
4179 }
4180 
4181 template<>
4182 inline void Collection<Clob>::SetElem(OCI_Elem *elem, const Clob &value)
4183 {
4184  Check(OCI_ElemSetLob(elem, value));
4185 }
4186 
4187 template<>
4188 inline void Collection<NClob>::SetElem(OCI_Elem *elem, const NClob &value)
4189 {
4190  Check(OCI_ElemSetLob(elem, value));
4191 }
4192 
4193 template<>
4194 inline void Collection<Blob>::SetElem(OCI_Elem *elem, const Blob &value)
4195 {
4196  Check(OCI_ElemSetLob(elem, value));
4197 }
4198 
4199 template<>
4200 inline void Collection<File>::SetElem(OCI_Elem *elem, const File &value)
4201 {
4202  Check(OCI_ElemSetFile(elem, value));
4203 }
4204 
4205 template<class T>
4206 void Collection<T>::SetElem(OCI_Elem *elem, const T &value)
4207 {
4208  Check(OCI_ElemSetColl(elem, value));
4209 }
4210 
4211 template<class T>
4213 {
4214  if (!IsNull())
4215  {
4216  unsigned int len = 0;
4217 
4218  Check(OCI_CollToText(*this, &len, nullptr));
4219 
4220  ManagedBuffer<otext> buffer(len + 1);
4221 
4222  Check(OCI_CollToText(*this, &len, buffer));
4223 
4224  return MakeString(static_cast<const otext *>(buffer), static_cast<int>(len));
4225  }
4226 
4227  return OCI_STRING_NULL;
4228 }
4229 
4230 template<class T>
4232 {
4233  return CollectionElement<T>(this, index);
4234 }
4235 
4236 template<class T>
4237 const CollectionElement<T> Collection<T>::operator [] (unsigned int index) const
4238 {
4239  return CollectionElement<T>(this, index);
4240 }
4241 
4242 template<class T>
4244 {
4245 
4246 }
4247 
4248 template<class T>
4249 CollectionIterator<T>::CollectionIterator(CollectionType *collection, unsigned int pos) : _elem(collection, pos)
4250 {
4251 
4252 }
4253 
4254 template<class T>
4255 CollectionIterator<T>::CollectionIterator(const CollectionIterator& other) : _elem(other._elem)
4256 {
4257 
4258 }
4259 
4260 template<class T>
4262 {
4263  _elem._pos = other._elem._pos;
4264  _elem._coll = other._elem._coll;
4265 
4266  return *this;
4267 }
4268 
4269 template<class T>
4271 {
4272  _elem._pos += static_cast<unsigned int>(value);
4273  return *this;
4274 }
4275 
4276 template<class T>
4278 {
4279  _elem._pos -= static_cast<unsigned int>(value);
4280  return *this;
4281 }
4282 
4283 template<class T>
4285 {
4286  return _elem;
4287 }
4288 
4289 template<class T>
4291 {
4292  return &_elem;
4293 }
4294 
4295 template<class T>
4297 {
4298  --_elem._pos;
4299  return *this;
4300 }
4301 
4302 template<class T>
4304 {
4305  ++*(const_cast<unsigned int*>(&_elem._pos));
4306  return *this;
4307 }
4308 
4309 template<class T>
4311 {
4312  CollectionIterator res(_elem._coll, _elem._pos);
4313  ++(*this);
4314  return res;
4315 }
4316 
4317 template<class T>
4319 {
4320  CollectionIterator res(_elem);
4321  --(*this);
4322  return res;
4323 }
4324 
4325 template<class T>
4327 {
4328  return CollectionIterator(_elem._coll, _elem._pos + static_cast<unsigned int>(value));
4329 }
4330 
4331 template<class T>
4333 {
4334  return CollectionIterator(_elem._coll, _elem._pos - static_cast<unsigned int>(value));
4335 }
4336 
4337 template<class T>
4338 typename CollectionIterator<T>::difference_type CollectionIterator<T>::operator - (const CollectionIterator &value)
4339 {
4340  return static_cast<difference_type>(_elem._pos - value._elem._pos);
4341 }
4342 
4343 template<class T>
4345 {
4346  return _elem._pos == other._elem._pos && (static_cast<OCI_Coll *>(*_elem._coll)) == (static_cast<OCI_Coll *>(*other._elem._coll));
4347 }
4348 
4349 template<class T>
4351 {
4352  return !(*this == other);
4353 }
4354 
4355 template<class T>
4357 {
4358  return _elem._pos > other._elem._pos;
4359 }
4360 
4361 template<class T>
4363 {
4364  return _elem._pos < other._elem._pos;
4365 }
4366 
4367 template<class T>
4369 {
4370  return _elem._pos >= other._elem._pos;
4371 }
4372 
4373 template<class T>
4375 {
4376  return _elem._pos <= other._elem._pos;
4377 }
4378 
4379 template<class T>
4380 CollectionElement<T>::CollectionElement() : _coll(nullptr), _pos(0)
4381 {
4382 
4383 }
4384 
4385 template<class T>
4386 CollectionElement<T>::CollectionElement(CollectionType *coll, unsigned int pos) : _coll(coll), _pos(pos)
4387 {
4388 
4389 }
4390 
4391 template<class T>
4393 {
4394  return _coll->Get(_pos);
4395 }
4396 
4397 template<class T>
4399 {
4400  _coll->Set(_pos, value);
4401  return *this;
4402 }
4403 
4404 template<class T>
4406 {
4407  _coll->Set(_pos, static_cast<T>(other));
4408  return *this;
4409 }
4410 
4411 template<class T>
4412 bool CollectionElement<T>::IsNull() const
4413 {
4414  return _coll->IsElementNull(_pos);
4415 }
4416 
4417 template<class T>
4419 {
4420  _coll->SetElementNull(_pos);
4421 }
4422 
4423 /* --------------------------------------------------------------------------------------------- *
4424  * Long
4425  * --------------------------------------------------------------------------------------------- */
4426 
4427 template<class T, int U>
4429 {
4430 }
4431 
4432 template<class T, int U>
4433 Long<T, U>::Long(const Statement &statement)
4434 {
4435  Acquire(Check(OCI_LongCreate(statement, U)), reinterpret_cast<HandleFreeFunc>(OCI_LongFree), nullptr, statement.GetHandle());
4436 }
4437 
4438 template<class T, int U>
4439 Long<T, U>::Long(OCI_Long *pLong, Handle* parent)
4440 {
4441  Acquire(pLong, nullptr, nullptr, parent);
4442 }
4443 
4444 template<class T, int U>
4445 unsigned int Long<T, U>::Write(const T& content)
4446 {
4447  unsigned int res = 0;
4448 
4449  if (content.size() > 0)
4450  {
4451  res = Check(OCI_LongWrite(*this, static_cast<AnyPointer>(const_cast<typename T::value_type *>(&content[0])), static_cast<unsigned int>(content.size())));
4452  }
4453 
4454  return res;
4455 }
4456 
4457 template<class T, int U>
4458 unsigned int Long<T, U>::GetLength() const
4459 {
4460  return Check(OCI_LongGetSize(*this));
4461 }
4462 
4463 template<>
4464 inline ostring Long<ostring, LongCharacter>::GetContent() const
4465 {
4466  return MakeString(static_cast<const otext *>(Check(OCI_LongGetBuffer(*this))));
4467 }
4468 
4469 template<>
4470 inline Raw Long<Raw, LongBinary>::GetContent() const
4471 {
4472  return MakeRaw(Check(OCI_LongGetBuffer(*this)), GetLength());
4473 }
4474 
4475 /* --------------------------------------------------------------------------------------------- *
4476  * BindObject
4477  * --------------------------------------------------------------------------------------------- */
4478 
4479 inline BindObject::BindObject(const Statement &statement, const ostring& name, unsigned int mode) : _pStatement(statement), _name(name), _mode(mode)
4480 {
4481 }
4482 
4483 inline BindObject::~BindObject()
4484 {
4485 }
4486 
4487 inline ostring BindObject::GetName() const
4488 {
4489  return _name;
4490 }
4491 
4492 inline Statement BindObject::GetStatement() const
4493 {
4494  return Statement(_pStatement);
4495 }
4496 
4497 inline unsigned int BindObject::GetMode() const
4498 {
4499  return _mode;
4500 }
4501 
4502 /* --------------------------------------------------------------------------------------------- *
4503  * BindArray
4504  * --------------------------------------------------------------------------------------------- */
4505 
4506 inline BindArray::BindArray(const Statement &statement, const ostring& name, unsigned int mode) : BindObject(statement, name, mode), _object(nullptr)
4507 {
4508 
4509 }
4510 
4511 template<class T>
4512 void BindArray::SetVector(std::vector<T> & vector, unsigned int elemSize)
4513 {
4514  _object = new BindArrayObject<T>(GetStatement(), GetName(), vector, GetMode(), elemSize);
4515 }
4516 
4517 inline BindArray::~BindArray()
4518 {
4519  delete _object;
4520 }
4521 
4522 template<class T>
4523 typename BindResolver<T>::OutputType * BindArray::GetData() const
4524 {
4525  return static_cast<typename BindResolver<T>::OutputType *>(*(dynamic_cast< BindArrayObject<T> * > (_object)));
4526 }
4527 
4528 inline void BindArray::SetInData()
4529 {
4530  if (GetMode() & OCI_BDM_IN)
4531  {
4532  _object->SetInData();
4533  }
4534 }
4535 
4536 inline void BindArray::SetOutData()
4537 {
4538  if (GetMode() & OCI_BDM_OUT)
4539  {
4540  _object->SetOutData();
4541  }
4542 }
4543 
4544 template<class T>
4545 BindArray::BindArrayObject<T>::BindArrayObject(const Statement &statement, const ostring& name, ObjectVector &vector, unsigned int mode, unsigned int elemSize)
4546  : _pStatement(statement), _name(name), _vector(vector), _data(nullptr), _mode(mode), _elemCount(statement.GetBindArraySize()), _elemSize(elemSize)
4547 {
4548  AllocData();
4549 }
4550 
4551 template<class T>
4552 BindArray::BindArrayObject<T>::~BindArrayObject()
4553 {
4554  FreeData();
4555 }
4556 
4557 template<class T>
4558 void BindArray::BindArrayObject<T>::AllocData()
4559 {
4560  _data = new NativeType[_elemCount];
4561 
4562  memset(_data, 0, sizeof(NativeType) * _elemCount);
4563 }
4564 
4565 template<>
4566 inline void BindArray::BindArrayObject<ostring>::AllocData()
4567 {
4568  _data = new otext[_elemSize * _elemCount];
4569 
4570  memset(_data, 0, _elemSize * _elemCount * sizeof(otext));
4571 }
4572 
4573 template<>
4574 inline void BindArray::BindArrayObject<Raw> ::AllocData()
4575 {
4576  _data = new unsigned char[_elemSize * _elemCount];
4577 
4578  memset(_data, 0, _elemSize * _elemCount * sizeof(unsigned char));
4579 }
4580 
4581 template<class T>
4582 void BindArray::BindArrayObject<T>::FreeData() const
4583 {
4584  delete [] _data ;
4585 }
4586 
4587 template<class T>
4588 void BindArray::BindArrayObject<T>::SetInData()
4589 {
4590  typename ObjectVector::iterator it, it_end;
4591 
4592  unsigned int index = 0;
4593  unsigned int currElemCount = Check(OCI_BindArrayGetSize(_pStatement));
4594 
4595  for (it = _vector.begin(), it_end = _vector.end(); it != it_end && index < _elemCount && index < currElemCount; ++it, ++index)
4596  {
4597  _data[index] = static_cast<NativeType>(*it);
4598  }
4599 }
4600 
4601 template<>
4602 inline void BindArray::BindArrayObject<ostring>::SetInData()
4603 {
4604  std::vector<ostring>::iterator it, it_end;
4605 
4606  unsigned int index = 0;
4607  unsigned int currElemCount = Check(OCI_BindArrayGetSize(_pStatement));
4608 
4609  for (it = _vector.begin(), it_end = _vector.end(); it != it_end && index < _elemCount && index < currElemCount; ++it, ++index)
4610  {
4611  const ostring & value = *it;
4612 
4613  memcpy( _data + (_elemSize * index), value.c_str(), (value.size() + 1) * sizeof(otext));
4614  }
4615 }
4616 
4617 template<>
4618 inline void BindArray::BindArrayObject<Raw>::SetInData()
4619 {
4620  std::vector<Raw>::iterator it, it_end;
4621 
4622  unsigned int index = 0;
4623  unsigned int currElemCount = Check(OCI_BindArrayGetSize(_pStatement));
4624 
4625  for (it = _vector.begin(), it_end = _vector.end(); it != it_end && index < _elemCount && index < currElemCount; ++it, ++index)
4626  {
4627  Raw & value = *it;
4628 
4629  if (value.size() > 0)
4630  {
4631  memcpy(_data + (_elemSize * index), &value[0], value.size());
4632  }
4633 
4634  OCI_BindSetDataSizeAtPos(OCI_GetBind2(_pStatement, GetName().c_str()), index + 1, static_cast<unsigned int>(value.size()));
4635  }
4636 }
4637 
4638 template<class T>
4639 void BindArray::BindArrayObject<T>::SetOutData()
4640 {
4641  typename ObjectVector::iterator it, it_end;
4642 
4643  unsigned int index = 0;
4644  unsigned int currElemCount = Check(OCI_BindArrayGetSize(_pStatement));
4645 
4646  for (it = _vector.begin(), it_end = _vector.end(); it != it_end && index < _elemCount && index < currElemCount; ++it, ++index)
4647  {
4648  T& object = *it;
4649 
4650  object = static_cast<NativeType>(_data[index]);
4651  }
4652 }
4653 
4654 template<>
4655 inline void BindArray::BindArrayObject<Raw>::SetOutData()
4656 {
4657  std::vector<Raw>::iterator it, it_end;
4658 
4659  OCI_Bind *pBind = Check(OCI_GetBind2(_pStatement, GetName().c_str()));
4660 
4661  unsigned int index = 0;
4662  unsigned int currElemCount = Check(OCI_BindArrayGetSize(_pStatement));
4663 
4664  for (it = _vector.begin(), it_end = _vector.end(); it != it_end && index < _elemCount && index < currElemCount; ++it, ++index)
4665  {
4666  unsigned char *currData = _data + (_elemSize * index);
4667 
4668  (*it).assign(currData, currData + Check(OCI_BindGetDataSizeAtPos(pBind, index + 1)));
4669  }
4670 }
4671 
4672 template<class T>
4673 ostring BindArray::BindArrayObject<T>::GetName()
4674 {
4675  return _name;
4676 }
4677 
4678 template<class T>
4679 BindArray::BindArrayObject<T>::operator ObjectVector & () const
4680 {
4681  return _vector;
4682 }
4683 
4684 template<class T>
4685 BindArray::BindArrayObject<T>::operator NativeType * () const
4686 {
4687  return _data;
4688 }
4689 
4690 /* --------------------------------------------------------------------------------------------- *
4691  * BindObjectAdaptor
4692  * --------------------------------------------------------------------------------------------- */
4693 
4694 template<class T>
4695 void BindObjectAdaptor<T>::SetInData()
4696 {
4697  if (GetMode() & OCI_BDM_IN)
4698  {
4699  size_t size = _object.size();
4700 
4701  if (size > _size)
4702  {
4703  size = _size;
4704  }
4705 
4706  if (size > 0)
4707  {
4708  memcpy(_data, &_object[0], size * sizeof(NativeType));
4709  }
4710 
4711  _data[size] = 0;
4712  }
4713 }
4714 
4715 template<class T>
4716 void BindObjectAdaptor<T>::SetOutData()
4717 {
4718  if (GetMode() & OCI_BDM_OUT)
4719  {
4720  size_t size = Check(OCI_BindGetDataSize(Check(OCI_GetBind2(_pStatement, _name.c_str()))));
4721 
4722  _object.assign(_data, _data + size);
4723  }
4724 }
4725 
4726 template<class T>
4727 BindObjectAdaptor<T>::BindObjectAdaptor(const Statement &statement, const ostring& name, unsigned int mode, ObjectType &object, unsigned int size) :
4728  BindObject(statement, name, mode),
4729  _object(object),
4730  _data(new NativeType[size]),
4731  _size(size)
4732 {
4733  memset(_data, 0, _size * sizeof(NativeType));
4734 }
4735 
4736 template<class T>
4737 BindObjectAdaptor<T>::~BindObjectAdaptor()
4738 {
4739  delete [] _data;
4740 }
4741 
4742 template<class T>
4743 BindObjectAdaptor<T>::operator NativeType *() const
4744 {
4745  return _data;
4746 }
4747 
4748 /* --------------------------------------------------------------------------------------------- *
4749  * BindTypeAdaptor
4750  * --------------------------------------------------------------------------------------------- */
4751 
4752 template<class T>
4753 void BindTypeAdaptor<T>::SetInData()
4754 {
4755  if (GetMode() & OCI_BDM_IN)
4756  {
4757  *_data = static_cast<NativeType>(_object);
4758  }
4759 }
4760 
4761 template<class T>
4762 void BindTypeAdaptor<T>::SetOutData()
4763 {
4764  if (GetMode() & OCI_BDM_OUT)
4765  {
4766  _object = static_cast<T>(*_data);
4767  }
4768 }
4769 
4770 template<class T>
4771 BindTypeAdaptor<T>::BindTypeAdaptor(const Statement &statement, const ostring& name, unsigned int mode, ObjectType &object) :
4772 BindObject(statement, name, mode),
4773 _object(object),
4774 _data(new NativeType)
4775 {
4776 
4777 }
4778 
4779 template<class T>
4780 BindTypeAdaptor<T>::~BindTypeAdaptor()
4781 {
4782  delete _data;
4783 }
4784 
4785 template<class T>
4786 BindTypeAdaptor<T>::operator NativeType *() const
4787 {
4788  return _data;
4789 }
4790 
4791 template<>
4792 inline void BindTypeAdaptor<bool>::SetInData()
4793 {
4794  if (GetMode() & OCI_BDM_IN)
4795  {
4796  *_data = (_object == true);
4797  }
4798 }
4799 
4800 template<>
4801 inline void BindTypeAdaptor<bool>::SetOutData()
4802 {
4803  if (GetMode() & OCI_BDM_OUT)
4804  {
4805  _object = (*_data == TRUE);
4806  }
4807 }
4808 
4809 /* --------------------------------------------------------------------------------------------- *
4810  * BindsHolder
4811  * --------------------------------------------------------------------------------------------- */
4812 
4813 inline BindsHolder::BindsHolder(const Statement &statement) : _bindObjects(), _pStatement(statement)
4814 {
4815 
4816 }
4817 
4818 inline BindsHolder::~BindsHolder()
4819 {
4820  Clear();
4821 }
4822 
4823 inline void BindsHolder::Clear()
4824 {
4825  std::vector<BindObject *>::iterator it, it_end;
4826 
4827  for(it = _bindObjects.begin(), it_end = _bindObjects.end(); it != it_end; ++it)
4828  {
4829  delete (*it);
4830  }
4831 
4832  _bindObjects.clear();
4833 }
4834 
4835 inline void BindsHolder::AddBindObject(BindObject *bindObject)
4836 {
4837  if (Check(OCI_IsRebindingAllowed(_pStatement)))
4838  {
4839  std::vector<BindObject *>::iterator it, it_end;
4840 
4841  for(it = _bindObjects.begin(), it_end = _bindObjects.end(); it != it_end; ++it)
4842  {
4843  if ((*it)->GetName() == bindObject->GetName())
4844  {
4845  _bindObjects.erase(it);
4846  break;
4847  }
4848  }
4849  }
4850 
4851  _bindObjects.push_back(bindObject);
4852 }
4853 
4854 inline void BindsHolder::SetOutData()
4855 {
4856  std::vector<BindObject *>::iterator it, it_end;
4857 
4858  for(it = _bindObjects.begin(), it_end = _bindObjects.end(); it != it_end; ++it)
4859  {
4860  (*it)->SetOutData();
4861  }
4862 }
4863 
4864 inline void BindsHolder::SetInData()
4865 {
4866  std::vector<BindObject *>::iterator it, it_end;
4867 
4868  for(it = _bindObjects.begin(), it_end = _bindObjects.end(); it != it_end; ++it)
4869  {
4870  (*it)->SetInData();
4871  }
4872 }
4873 
4874 /* --------------------------------------------------------------------------------------------- *
4875  * Bind
4876  * --------------------------------------------------------------------------------------------- */
4877 
4878 inline BindInfo::BindInfo(OCI_Bind *pBind, Handle *parent)
4879 {
4880  Acquire(pBind, nullptr, nullptr, parent);
4881 }
4882 
4883 inline ostring BindInfo::GetName() const
4884 {
4885  return MakeString(Check(OCI_BindGetName(*this)));
4886 }
4887 
4889 {
4890  return DataType(static_cast<DataType::Type>(Check(OCI_BindGetType(*this))));
4891 }
4892 
4893 inline unsigned int BindInfo::GetSubType() const
4894 {
4895  return Check(OCI_BindGetSubtype(*this));
4896 }
4897 
4898 inline unsigned int BindInfo::GetDataCount() const
4899 {
4900  return Check(OCI_BindGetDataCount(*this));
4901 }
4902 
4903 inline Statement BindInfo::GetStatement() const
4904 {
4905  return Statement(Check(OCI_BindGetStatement(*this)));
4906 }
4907 
4908 inline void BindInfo::SetDataNull(bool value, unsigned int index)
4909 {
4910  if (value)
4911  {
4912  Check(OCI_BindSetNullAtPos(*this, index));
4913  }
4914  else
4915  {
4916  Check(OCI_BindSetNotNullAtPos(*this, index));
4917  }
4918 }
4919 
4920 inline bool BindInfo::IsDataNull(unsigned int index) const
4921 {
4922  return (Check(OCI_BindIsNullAtPos(*this, index)) == TRUE);
4923 }
4924 
4926 {
4927  Check(OCI_BindSetCharsetForm(*this, value));
4928 }
4929 
4931 {
4932  return BindDirection(static_cast<BindDirection::Type>(Check(OCI_BindGetDirection(*this))));
4933 }
4934 
4935 /* --------------------------------------------------------------------------------------------- *
4936  * Statement
4937  * --------------------------------------------------------------------------------------------- */
4938 
4940 {
4941 }
4942 
4943 inline Statement::Statement(const Connection &connection)
4944 {
4945  Acquire(Check(OCI_StatementCreate(connection)), reinterpret_cast<HandleFreeFunc>(OCI_StatementFree), OnFreeSmartHandle, connection.GetHandle());
4946 }
4947 
4948 inline Statement::Statement(OCI_Statement *stmt, Handle *parent)
4949 {
4950  Acquire(stmt, reinterpret_cast<HandleFreeFunc>(parent ? OCI_StatementFree : nullptr), OnFreeSmartHandle, parent);
4951 }
4952 
4954 {
4955  return Connection(Check(OCI_StatementGetConnection(*this)), nullptr);
4956 }
4957 
4958 inline void Statement::Describe(const ostring& sql)
4959 {
4960  ClearBinds();
4961  ReleaseResultsets();
4962  Check(OCI_Describe(*this, sql.c_str()));
4963 }
4964 
4965 inline void Statement::Parse(const ostring& sql)
4966 {
4967  ClearBinds();
4968  ReleaseResultsets();
4969  Check(OCI_Parse(*this, sql.c_str()));
4970 }
4971 
4972 inline void Statement::Prepare(const ostring& sql)
4973 {
4974  ClearBinds();
4975  ReleaseResultsets();
4976  Check(OCI_Prepare(*this, sql.c_str()));
4977 }
4978 
4980 {
4981  ReleaseResultsets();
4982  SetInData();
4983  Check(OCI_Execute(*this));
4984  SetOutData();
4985 }
4986 
4987 template<class T>
4988 unsigned int Statement::ExecutePrepared(T callback)
4989 {
4990  ExecutePrepared();
4991 
4992  return Fetch(callback);
4993 }
4994 
4995 template<class T, class U>
4996 unsigned int Statement::ExecutePrepared(T callback, U adapter)
4997 {
4998  ExecutePrepared();
4999 
5000  return Fetch(callback, adapter);
5001 }
5002 
5003 inline void Statement::Execute(const ostring& sql)
5004 {
5005  ClearBinds();
5006  ReleaseResultsets();
5007  Check(OCI_ExecuteStmt(*this, sql.c_str()));
5008 }
5009 
5010 template<class T>
5011 unsigned int Statement::Execute(const ostring& sql, T callback)
5012 {
5013  Execute(sql);
5014 
5015  return Fetch(callback);
5016 }
5017 
5018 template<class T, class U>
5019 unsigned int Statement::Execute(const ostring& sql, T callback, U adapter)
5020 {
5021  Execute(sql);
5022 
5023  return Fetch(callback, adapter);
5024 }
5025 
5026 template<typename T>
5027 unsigned int Statement::Fetch(T callback)
5028 {
5029  unsigned int res = 0;
5030 
5031  Resultset rs = GetResultset();
5032 
5033  while (rs)
5034  {
5035  res += rs.ForEach(callback);
5036  rs = GetNextResultset();
5037  }
5038 
5039  return res;
5040 }
5041 
5042 template<class T, class U>
5043 unsigned int Statement::Fetch(T callback, U adapter)
5044 {
5045  unsigned int res = 0;
5046 
5047  Resultset rs = GetResultset();
5048 
5049  while (rs)
5050  {
5051  res += rs.ForEach(callback, adapter);
5052  rs = GetNextResultset();
5053  }
5054 
5055  return res;
5056 }
5057 
5058 inline unsigned int Statement::GetAffectedRows() const
5059 {
5060  return Check(OCI_GetAffectedRows(*this));
5061 }
5062 
5063 inline ostring Statement::GetSql() const
5064 {
5065  return MakeString(Check(OCI_GetSql(*this)));
5066 }
5067 
5069 {
5070  return Resultset(Check(OCI_GetResultset(*this)), GetHandle());
5071 }
5072 
5074 {
5075  return Resultset(Check(OCI_GetNextResultset(*this)), GetHandle());
5076 }
5077 
5078 inline void Statement::SetBindArraySize(unsigned int size)
5079 {
5080  Check(OCI_BindArraySetSize(*this, size));
5081 }
5082 
5083 inline unsigned int Statement::GetBindArraySize() const
5084 {
5085  return Check(OCI_BindArrayGetSize(*this));
5086 }
5087 
5088 inline void Statement::AllowRebinding(bool value)
5089 {
5090  Check(OCI_AllowRebinding(*this, value));
5091 }
5092 
5094 {
5095  return (Check(OCI_IsRebindingAllowed(*this)) == TRUE);
5096 }
5097 
5098 inline unsigned int Statement::GetBindIndex(const ostring& name) const
5099 {
5100  return Check(OCI_GetBindIndex(*this, name.c_str()));
5101 }
5102 
5103 inline unsigned int Statement::GetBindCount() const
5104 {
5105  return Check(OCI_GetBindCount(*this));
5106 }
5107 
5108 inline BindInfo Statement::GetBind(unsigned int index) const
5109 {
5110  return BindInfo(Check(OCI_GetBind(*this, index)), GetHandle());
5111 }
5112 
5113 inline BindInfo Statement::GetBind(const ostring& name) const
5114 {
5115  return BindInfo(Check(OCI_GetBind2(*this, name.c_str())), GetHandle());
5116 }
5117 
5118 template<typename M, class T>
5119 void Statement::Bind1(M &method, const ostring& name, T& value, BindInfo::BindDirection mode)
5120 {
5121  Check(method(*this, name.c_str(), &value));
5122  SetLastBindMode(mode);
5123 }
5124 
5125 template<typename M, class T>
5126 void Statement::Bind2(M &method, const ostring& name, T& value, BindInfo::BindDirection mode)
5127 {
5128  Check(method(*this, name.c_str(), static_cast<typename BindResolver<T>::OutputType>(value)));
5129  SetLastBindMode(mode);
5130 }
5131 
5132 template<typename M, class T>
5133 void Statement::BindVector1(M &method, const ostring& name, std::vector<T> &values, BindInfo::BindDirection mode)
5134 {
5135  BindArray * bnd = new BindArray(*this, name, mode);
5136  bnd->SetVector<T>(values, sizeof(typename BindResolver<T>::OutputType));
5137 
5138  boolean res = method(*this, name.c_str(), bnd->GetData<T>(), 0);
5139 
5140  if (res)
5141  {
5142  BindsHolder *bindsHolder = GetBindsHolder(true);
5143  bindsHolder->AddBindObject(bnd);
5144  SetLastBindMode(mode);
5145  }
5146  else
5147  {
5148  delete bnd;
5149  }
5150 
5151  Check(res);
5152 }
5153 
5154 template<typename M, class T, class U>
5155 void Statement::BindVector2(M &method, const ostring& name, std::vector<T> &values, BindInfo::BindDirection mode, U type)
5156 {
5157  BindArray * bnd = new BindArray(*this, name, mode);
5158  bnd->SetVector<T>(values, sizeof(typename BindResolver<T>::OutputType));
5159 
5160  boolean res = method(*this, name.c_str(), bnd->GetData<T>(), type, 0);
5161 
5162  if (res)
5163  {
5164  BindsHolder *bindsHolder = GetBindsHolder(true);
5165  bindsHolder->AddBindObject(bnd);
5166  SetLastBindMode(mode);
5167  }
5168  else
5169  {
5170  delete bnd;
5171  }
5172 
5173  Check(res);
5174 }
5175 
5176 template<>
5177 inline void Statement::Bind<bool>(const ostring& name, bool &value, BindInfo::BindDirection mode)
5178 {
5179  BindTypeAdaptor<bool> * bnd = new BindTypeAdaptor<bool>(*this, name, mode, value);
5180 
5181  boolean res = OCI_BindBoolean(*this, name.c_str(), static_cast<boolean *>(*bnd));
5182 
5183  if (res)
5184  {
5185  BindsHolder *bindsHolder = GetBindsHolder(true);
5186  bindsHolder->AddBindObject(bnd);
5187  SetLastBindMode(mode);
5188  }
5189  else
5190  {
5191  delete bnd;
5192  }
5193 
5194  Check(res);
5195 }
5196 
5197 template<>
5198 inline void Statement::Bind<short>(const ostring& name, short &value, BindInfo::BindDirection mode)
5199 {
5200  Bind1(OCI_BindShort, name, value, mode);
5201 }
5202 
5203 template<>
5204 inline void Statement::Bind<unsigned short>(const ostring& name, unsigned short &value, BindInfo::BindDirection mode)
5205 {
5206  Bind1(OCI_BindUnsignedShort, name, value, mode);
5207 }
5208 
5209 template<>
5210 inline void Statement::Bind<int>(const ostring& name, int &value, BindInfo::BindDirection mode)
5211 {
5212  Bind1(OCI_BindInt, name, value, mode);
5213 }
5214 
5215 template<>
5216 inline void Statement::Bind<unsigned int>(const ostring& name, unsigned int &value, BindInfo::BindDirection mode)
5217 {
5218  Bind1(OCI_BindUnsignedInt, name, value, mode);
5219 }
5220 
5221 template<>
5222 inline void Statement::Bind<big_int>(const ostring& name, big_int &value, BindInfo::BindDirection mode)
5223 {
5224  Bind1(OCI_BindBigInt, name, value, mode);
5225 }
5226 
5227 template<>
5228 inline void Statement::Bind<big_uint>(const ostring& name, big_uint &value, BindInfo::BindDirection mode)
5229 {
5230  Bind1(OCI_BindUnsignedBigInt, name, value, mode);
5231 }
5232 
5233 template<>
5234 inline void Statement::Bind<float>(const ostring& name, float &value, BindInfo::BindDirection mode)
5235 {
5236  Bind1(OCI_BindFloat, name, value, mode);
5237 }
5238 
5239 template<>
5240 inline void Statement::Bind<double>(const ostring& name, double &value, BindInfo::BindDirection mode)
5241 {
5242  Bind1(OCI_BindDouble, name, value, mode);
5243 }
5244 
5245 template<>
5246 inline void Statement::Bind<Number>(const ostring& name, Number &value, BindInfo::BindDirection mode)
5247 {
5248  Bind2(OCI_BindNumber, name, value, mode);
5249 }
5250 
5251 template<>
5252 inline void Statement::Bind<Date>(const ostring& name, Date &value, BindInfo::BindDirection mode)
5253 {
5254  Bind2(OCI_BindDate, name, value, mode);
5255 }
5256 
5257 template<>
5258 inline void Statement::Bind<Timestamp>(const ostring& name, Timestamp &value, BindInfo::BindDirection mode)
5259 {
5260  Bind2(OCI_BindTimestamp, name, value, mode);
5261 }
5262 
5263 template<>
5264 inline void Statement::Bind<Interval>(const ostring& name, Interval &value, BindInfo::BindDirection mode)
5265 {
5266  Bind2(OCI_BindInterval, name, value, mode);
5267 }
5268 
5269 template<>
5270 inline void Statement::Bind<Clob>(const ostring& name, Clob &value, BindInfo::BindDirection mode)
5271 {
5272  Bind2(OCI_BindLob, name, value, mode);
5273 }
5274 
5275 template<>
5276 inline void Statement::Bind<NClob>(const ostring& name, NClob &value, BindInfo::BindDirection mode)
5277 {
5278  Bind2(OCI_BindLob, name, value, mode);
5279 }
5280 
5281 template<>
5282 inline void Statement::Bind<Blob>(const ostring& name, Blob &value, BindInfo::BindDirection mode)
5283 {
5284  Bind2(OCI_BindLob, name, value, mode);
5285 }
5286 
5287 template<>
5288 inline void Statement::Bind<File>(const ostring& name, File &value, BindInfo::BindDirection mode)
5289 {
5290  Bind2(OCI_BindFile, name, value, mode);
5291 }
5292 
5293 template<>
5294 inline void Statement::Bind<Object>(const ostring& name, Object &value, BindInfo::BindDirection mode)
5295 {
5296  Bind2(OCI_BindObject, name, value, mode);
5297 }
5298 
5299 template<>
5300 inline void Statement::Bind<Reference>(const ostring& name, Reference &value, BindInfo::BindDirection mode)
5301 {
5302  Bind2(OCI_BindRef, name, value, mode);
5303 }
5304 
5305 template<>
5306 inline void Statement::Bind<Statement>(const ostring& name, Statement &value, BindInfo::BindDirection mode)
5307 {
5308  Bind2(OCI_BindStatement, name, value, mode);
5309 }
5310 
5311 template<>
5312 inline void Statement::Bind<Clong, unsigned int>(const ostring& name, Clong &value, unsigned int maxSize, BindInfo::BindDirection mode)
5313 {
5314  Check(OCI_BindLong(*this, name.c_str(), value, maxSize));
5315  SetLastBindMode(mode);
5316 }
5317 
5318 template<>
5319 inline void Statement::Bind<Clong, int>(const ostring& name, Clong &value, int maxSize, BindInfo::BindDirection mode)
5320 {
5321  Bind<Clong, unsigned int>(name, value, static_cast<unsigned int>(maxSize), mode);
5322 }
5323 
5324 template<>
5325 inline void Statement::Bind<Blong, unsigned int>(const ostring& name, Blong &value, unsigned int maxSize, BindInfo::BindDirection mode)
5326 {
5327  Check(OCI_BindLong(*this, name.c_str(), value, maxSize));
5328  SetLastBindMode(mode);
5329 }
5330 
5331 template<>
5332 inline void Statement::Bind<Blong, int>(const ostring& name, Blong &value, int maxSize, BindInfo::BindDirection mode)
5333 {
5334  Bind<Blong, unsigned int>(name, value, static_cast<unsigned int>(maxSize), mode);
5335 }
5336 
5337 template<>
5338 inline void Statement::Bind<ostring, unsigned int>(const ostring& name, ostring &value, unsigned int maxSize, BindInfo::BindDirection mode)
5339 {
5340  if (maxSize == 0)
5341  {
5342  maxSize = static_cast<unsigned int>(value.size());
5343  }
5344 
5345  value.reserve(maxSize);
5346 
5347  BindObjectAdaptor<ostring> * bnd = new BindObjectAdaptor<ostring>(*this, name, mode, value, maxSize + 1);
5348 
5349  boolean res = OCI_BindString(*this, name.c_str(), static_cast<otext *>(*bnd), maxSize);
5350 
5351  if (res)
5352  {
5353  BindsHolder *bindsHolder = GetBindsHolder(true);
5354  bindsHolder->AddBindObject(bnd);
5355  SetLastBindMode(mode);
5356  }
5357  else
5358  {
5359  delete bnd;
5360  }
5361 
5362  Check(res);
5363 }
5364 
5365 template<>
5366 inline void Statement::Bind<ostring, int>(const ostring& name, ostring &value, int maxSize, BindInfo::BindDirection mode)
5367 {
5368  Bind<ostring, unsigned int>(name, value, static_cast<unsigned int>(maxSize), mode);
5369 }
5370 
5371 template<>
5372 inline void Statement::Bind<Raw, unsigned int>(const ostring& name, Raw &value, unsigned int maxSize, BindInfo::BindDirection mode)
5373 {
5374  if (maxSize == 0)
5375  {
5376  maxSize = static_cast<unsigned int>(value.size());
5377  }
5378 
5379  value.reserve(maxSize);
5380 
5381  BindObjectAdaptor<Raw> * bnd = new BindObjectAdaptor<Raw>(*this, name, mode, value, maxSize);
5382 
5383  boolean res = OCI_BindRaw(*this, name.c_str(), static_cast<unsigned char *>(*bnd), maxSize);
5384 
5385  if (res)
5386  {
5387  BindsHolder *bindsHolder = GetBindsHolder(true);
5388  bindsHolder->AddBindObject(bnd);
5389  SetLastBindMode(mode);
5390  }
5391  else
5392  {
5393  delete bnd;
5394  }
5395 
5396  Check(res);
5397 }
5398 
5399 template<>
5400 inline void Statement::Bind<Raw, int>(const ostring& name, Raw &value, int maxSize, BindInfo::BindDirection mode)
5401 {
5402  Bind<Raw, unsigned int>(name, value, static_cast<unsigned int>(maxSize), mode);
5403 }
5404 
5405 template<>
5406 inline void Statement::Bind<short>(const ostring& name, std::vector<short> &values, BindInfo::BindDirection mode)
5407 {
5408  BindVector1(OCI_BindArrayOfShorts, name, values, mode);
5409 }
5410 
5411 template<>
5412 inline void Statement::Bind<unsigned short>(const ostring& name, std::vector<unsigned short> &values, BindInfo::BindDirection mode)
5413 {
5414  BindVector1(OCI_BindArrayOfUnsignedShorts, name, values, mode);
5415 }
5416 
5417 template<>
5418 inline void Statement::Bind<int>(const ostring& name, std::vector<int> &values, BindInfo::BindDirection mode)
5419 {
5420  BindVector1(OCI_BindArrayOfInts, name, values, mode);
5421 }
5422 
5423 template<>
5424 inline void Statement::Bind<unsigned int>(const ostring& name, std::vector<unsigned int> &values, BindInfo::BindDirection mode)
5425 {
5426  BindVector1(OCI_BindArrayOfUnsignedInts, name, values, mode);
5427 }
5428 
5429 template<>
5430 inline void Statement::Bind<big_int>(const ostring& name, std::vector<big_int> &values, BindInfo::BindDirection mode)
5431 {
5432  BindVector1(OCI_BindArrayOfBigInts, name, values, mode);
5433 }
5434 
5435 template<>
5436 inline void Statement::Bind<big_uint>(const ostring& name, std::vector<big_uint> &values, BindInfo::BindDirection mode)
5437 {
5438  BindVector1(OCI_BindArrayOfUnsignedBigInts, name, values, mode);
5439 }
5440 
5441 template<>
5442 inline void Statement::Bind<float>(const ostring& name, std::vector<float> &values, BindInfo::BindDirection mode)
5443 {
5444  BindVector1(OCI_BindArrayOfFloats, name, values, mode);
5445 }
5446 
5447 template<>
5448 inline void Statement::Bind<double>(const ostring& name, std::vector<double> &values, BindInfo::BindDirection mode)
5449 {
5450  BindVector1(OCI_BindArrayOfDoubles, name, values, mode);
5451 }
5452 
5453 template<>
5454 inline void Statement::Bind<Date>(const ostring& name, std::vector<Date> &values, BindInfo::BindDirection mode)
5455 {
5456  BindVector1(OCI_BindArrayOfDates, name, values, mode);
5457 }
5458 
5459 template<>
5460 inline void Statement::Bind<Number>(const ostring& name, std::vector<Number> &values, BindInfo::BindDirection mode)
5461 {
5462  BindVector1(OCI_BindArrayOfNumbers, name, values, mode);
5463 }
5464 
5465 template<class T>
5466 void Statement::Bind(const ostring& name, Collection<T> &value, BindInfo::BindDirection mode)
5467 {
5468  Check(OCI_BindColl(*this, name.c_str(), value));
5469  SetLastBindMode(mode);
5470 }
5471 
5472 template<>
5473 inline void Statement::Bind<Timestamp, Timestamp::TimestampTypeValues>(const ostring& name, std::vector<Timestamp> &values, Timestamp::TimestampTypeValues type, BindInfo::BindDirection mode)
5474 {
5475  BindVector2(OCI_BindArrayOfTimestamps, name, values, mode, type);
5476 }
5477 
5478 template<>
5479 inline void Statement::Bind<Timestamp, Timestamp::TimestampType>(const ostring& name, std::vector<Timestamp> &values, Timestamp::TimestampType type, BindInfo::BindDirection mode)
5480 {
5481  Bind<Timestamp, Timestamp::TimestampTypeValues>(name, values, type.GetValue(), mode);
5482 }
5483 
5484 template<>
5485 inline void Statement::Bind<Interval, Interval::IntervalTypeValues>(const ostring& name, std::vector<Interval> &values, Interval::IntervalTypeValues type, BindInfo::BindDirection mode)
5486 {
5487  BindVector2(OCI_BindArrayOfIntervals, name, values, mode, type);
5488 }
5489 
5490 template<>
5491 inline void Statement::Bind<Interval, Interval::IntervalType>(const ostring& name, std::vector<Interval> &values, Interval::IntervalType type, BindInfo::BindDirection mode)
5492 {
5493  Bind<Interval, Interval::IntervalTypeValues>(name, values, type.GetValue(), mode);
5494 }
5495 
5496 template<>
5497 inline void Statement::Bind<Clob>(const ostring& name, std::vector<Clob> &values, BindInfo::BindDirection mode)
5498 {
5499  BindVector2(OCI_BindArrayOfLobs, name, values, mode, static_cast<unsigned int>(OCI_CLOB));
5500 }
5501 
5502 template<>
5503 inline void Statement::Bind<NClob>(const ostring& name, std::vector<NClob> &values, BindInfo::BindDirection mode)
5504 {
5505  BindVector2(OCI_BindArrayOfLobs, name, values, mode, static_cast<unsigned int>(OCI_NCLOB));
5506 }
5507 
5508 template<>
5509 inline void Statement::Bind<Blob>(const ostring& name, std::vector<Blob> &values, BindInfo::BindDirection mode)
5510 {
5511  BindVector2(OCI_BindArrayOfLobs, name, values, mode, static_cast<unsigned int>(OCI_BLOB));
5512 }
5513 
5514 template<>
5515 inline void Statement::Bind<File>(const ostring& name, std::vector<File> &values, BindInfo::BindDirection mode)
5516 {
5517  BindVector2(OCI_BindArrayOfFiles, name, values, mode, static_cast<unsigned int>(OCI_BFILE));
5518 }
5519 
5520 template<>
5521 inline void Statement::Bind<Object>(const ostring& name, std::vector<Object> &values, TypeInfo &typeInfo, BindInfo::BindDirection mode)
5522 {
5523  BindVector2(OCI_BindArrayOfObjects, name, values, mode, static_cast<OCI_TypeInfo *>(typeInfo));
5524 }
5525 
5526 template<>
5527 inline void Statement::Bind<Reference>(const ostring& name, std::vector<Reference> &values, TypeInfo &typeInfo, BindInfo::BindDirection mode)
5528 {
5529  BindVector2(OCI_BindArrayOfRefs, name, values, mode, static_cast<OCI_TypeInfo *>(typeInfo));
5530 }
5531 
5532 template<class T>
5533 void Statement::Bind(const ostring& name, std::vector<Collection<T> > &values, TypeInfo &typeInfo, BindInfo::BindDirection mode)
5534 {
5535  BindVector2(OCI_BindArrayOfColls, name, values, mode, static_cast<OCI_TypeInfo *>(typeInfo));
5536 }
5537 
5538 template<>
5539 inline void Statement::Bind<ostring, unsigned int>(const ostring& name, std::vector<ostring> &values, unsigned int maxSize, BindInfo::BindDirection mode)
5540 {
5541  BindArray * bnd = new BindArray(*this, name, mode);
5542  bnd->SetVector<ostring>(values, maxSize+1);
5543 
5544  boolean res = OCI_BindArrayOfStrings(*this, name.c_str(), bnd->GetData<ostring>(), maxSize, 0);
5545 
5546  if (res)
5547  {
5548  BindsHolder *bindsHolder = GetBindsHolder(true);
5549  bindsHolder->AddBindObject(bnd);
5550  SetLastBindMode(mode);
5551  }
5552  else
5553  {
5554  delete bnd;
5555  }
5556 
5557  Check(res);
5558 }
5559 
5560 template<>
5561 inline void Statement::Bind<ostring, int>(const ostring& name, std::vector<ostring> &values, int maxSize, BindInfo::BindDirection mode)
5562 {
5563  Bind<ostring, unsigned int>(name, values, static_cast<unsigned int>(maxSize), mode);
5564 }
5565 
5566 template<>
5567 inline void Statement::Bind<Raw, unsigned int>(const ostring& name, std::vector<Raw> &values, unsigned int maxSize, BindInfo::BindDirection mode)
5568 {
5569  BindArray * bnd = new BindArray(*this, name, mode);
5570  bnd->SetVector<Raw>(values, maxSize);
5571 
5572  boolean res = OCI_BindArrayOfRaws(*this, name.c_str(), bnd->GetData<Raw>(), maxSize, 0);
5573 
5574  if (res)
5575  {
5576  BindsHolder *bindsHolder = GetBindsHolder(true);
5577  bindsHolder->AddBindObject(bnd);
5578  SetLastBindMode(mode);
5579  }
5580  else
5581  {
5582  delete bnd;
5583  }
5584 
5585  Check(res);
5586 }
5587 
5588 template<class T>
5589 void Statement::Bind(const ostring& name, std::vector<T> &values, TypeInfo &typeInfo, BindInfo::BindDirection mode)
5590 {
5591  BindVector2(OCI_BindArrayOfColls, name, values, mode, static_cast<OCI_TypeInfo *>(typeInfo));
5592 }
5593 
5594 template<>
5595 inline void Statement::Register<unsigned short>(const ostring& name)
5596 {
5597  Check(OCI_RegisterUnsignedShort(*this, name.c_str()));
5598 }
5599 
5600 template<>
5601 inline void Statement::Register<short>(const ostring& name)
5602 {
5603  Check(OCI_RegisterShort(*this, name.c_str()));
5604 }
5605 
5606 template<>
5607 inline void Statement::Register<unsigned int>(const ostring& name)
5608 {
5609  Check(OCI_RegisterUnsignedInt(*this, name.c_str()));
5610 }
5611 
5612 template<>
5613 inline void Statement::Register<int>(const ostring& name)
5614 {
5615  Check(OCI_RegisterInt(*this, name.c_str()));
5616 }
5617 
5618 template<>
5619 inline void Statement::Register<big_uint>(const ostring& name)
5620 {
5621  Check(OCI_RegisterUnsignedBigInt(*this, name.c_str()));
5622 }
5623 
5624 template<>
5625 inline void Statement::Register<big_int>(const ostring& name)
5626 {
5627  Check(OCI_RegisterBigInt(*this, name.c_str()));
5628 }
5629 
5630 template<>
5631 inline void Statement::Register<float>(const ostring& name)
5632 {
5633  Check(OCI_RegisterFloat(*this, name.c_str()));
5634 }
5635 
5636 template<>
5637 inline void Statement::Register<double>(const ostring& name)
5638 {
5639  Check(OCI_RegisterDouble(*this, name.c_str()));
5640 }
5641 
5642 template<>
5643 inline void Statement::Register<Number>(const ostring& name)
5644 {
5645  Check(OCI_RegisterNumber(*this, name.c_str()));
5646 }
5647 
5648 template<>
5649 inline void Statement::Register<Date>(const ostring& name)
5650 {
5651  Check(OCI_RegisterDate(*this, name.c_str()));
5652 }
5653 
5654 template<>
5655 inline void Statement::Register<Timestamp, Timestamp::TimestampTypeValues>(const ostring& name, Timestamp::TimestampTypeValues type)
5656 {
5657  Check(OCI_RegisterTimestamp(*this, name.c_str(), type));
5658 }
5659 
5660 template<>
5661 inline void Statement::Register<Timestamp, Timestamp::TimestampType>(const ostring& name, Timestamp::TimestampType type)
5662 {
5663  Register<Timestamp, Timestamp::TimestampTypeValues>(name, type.GetValue());
5664 }
5665 
5666 template<>
5667 inline void Statement::Register<Interval, Interval::IntervalTypeValues>(const ostring& name, Interval::IntervalTypeValues type)
5668 {
5669  Check(OCI_RegisterInterval(*this, name.c_str(), type));
5670 }
5671 
5672 template<>
5673 inline void Statement::Register<Interval, Interval::IntervalType>(const ostring& name, Interval::IntervalType type)
5674 {
5675  Register<Interval, Interval::IntervalTypeValues>(name, type.GetValue());
5676 }
5677 
5678 template<>
5679 inline void Statement::Register<Clob>(const ostring& name)
5680 {
5681  Check(OCI_RegisterLob(*this, name.c_str(), OCI_CLOB));
5682 }
5683 
5684 template<>
5685 inline void Statement::Register<NClob>(const ostring& name)
5686 {
5687  Check(OCI_RegisterLob(*this, name.c_str(), OCI_NCLOB));
5688 }
5689 
5690 template<>
5691 inline void Statement::Register<Blob>(const ostring& name)
5692 {
5693  Check(OCI_RegisterLob(*this, name.c_str(), OCI_BLOB));
5694 }
5695 
5696 template<>
5697 inline void Statement::Register<File>(const ostring& name)
5698 {
5699  Check(OCI_RegisterFile(*this, name.c_str(), OCI_BFILE));
5700 }
5701 
5702 template<>
5703 inline void Statement::Register<Object, TypeInfo>(const ostring& name, TypeInfo& typeInfo)
5704 {
5705  Check(OCI_RegisterObject(*this, name.c_str(), typeInfo));
5706 }
5707 
5708 template<>
5709 inline void Statement::Register<Reference, TypeInfo>(const ostring& name, TypeInfo& typeInfo)
5710 {
5711  Check(OCI_RegisterRef(*this, name.c_str(), typeInfo));
5712 }
5713 
5714 template<>
5715 inline void Statement::Register<ostring, unsigned int>(const ostring& name, unsigned int len)
5716 {
5717  Check(OCI_RegisterString(*this, name.c_str(), len));
5718 }
5719 
5720 template<>
5721 inline void Statement::Register<ostring, int>(const ostring& name, int len)
5722 {
5723  Register<ostring, unsigned int>(name, static_cast<unsigned int>(len));
5724 }
5725 
5726 template<>
5727 inline void Statement::Register<Raw, unsigned int>(const ostring& name, unsigned int len)
5728 {
5729  Check(OCI_RegisterRaw(*this, name.c_str(), len));
5730 }
5731 
5732 template<>
5733 inline void Statement::Register<Raw, int>(const ostring& name, int len)
5734 {
5735  Register<Raw, unsigned int>(name, static_cast<unsigned int>(len));
5736 }
5737 
5739 {
5740  return StatementType(static_cast<StatementType::Type>(Check(OCI_GetStatementType(*this))));
5741 }
5742 
5743 inline unsigned int Statement::GetSqlErrorPos() const
5744 {
5745  return Check(OCI_GetSqlErrorPos(*this));
5746 }
5747 
5749 {
5750  Check(OCI_SetFetchMode(*this, value));
5751 }
5752 
5754 {
5755  return FetchMode(static_cast<FetchMode::Type>(Check(OCI_GetFetchMode(*this))));
5756 }
5757 
5759 {
5760  Check(OCI_SetBindMode(*this, value));
5761 }
5762 
5764 {
5765  return BindMode(static_cast<BindMode::Type>(Check(OCI_GetBindMode(*this))));
5766 }
5767 
5768 inline void Statement::SetFetchSize(unsigned int value)
5769 {
5770  Check(OCI_SetFetchSize(*this, value));
5771 }
5772 
5773 inline unsigned int Statement::GetFetchSize() const
5774 {
5775  return Check(OCI_GetFetchSize(*this));
5776 }
5777 
5778 inline void Statement::SetPrefetchSize(unsigned int value)
5779 {
5780  Check(OCI_SetPrefetchSize(*this, value));
5781 }
5782 
5783 inline unsigned int Statement::GetPrefetchSize() const
5784 {
5785  return Check(OCI_GetPrefetchSize(*this));
5786 }
5787 
5788 inline void Statement::SetPrefetchMemory(unsigned int value)
5789 {
5790  Check(OCI_SetPrefetchMemory(*this, value));
5791 }
5792 
5793 inline unsigned int Statement::GetPrefetchMemory() const
5794 {
5795  return Check(OCI_GetPrefetchMemory(*this));
5796 }
5797 
5798 inline void Statement::SetLongMaxSize(unsigned int value)
5799 {
5800  Check(OCI_SetLongMaxSize(*this, value));
5801 }
5802 
5803 inline unsigned int Statement::GetLongMaxSize() const
5804 {
5805  return Check(OCI_GetLongMaxSize(*this));
5806 }
5807 
5809 {
5810  Check(OCI_SetLongMode(*this, value));
5811 }
5812 
5814 {
5815  return LongMode(static_cast<LongMode::Type>(Check(OCI_GetLongMode(*this))));
5816 }
5817 
5818 inline unsigned int Statement::GetSQLCommand() const
5819 {
5820  return Check(OCI_GetSQLCommand(*this));
5821 }
5822 
5823 inline ostring Statement::GetSQLVerb() const
5824 {
5825  return MakeString(Check(OCI_GetSQLVerb(*this)));
5826 }
5827 
5828 inline void Statement::GetBatchErrors(std::vector<Exception> &exceptions)
5829 {
5830  exceptions.clear();
5831 
5832  OCI_Error *err = Check(OCI_GetBatchError(*this));
5833 
5834  while (err)
5835  {
5836  exceptions.push_back(Exception(err));
5837 
5838  err = Check(OCI_GetBatchError(*this));
5839  }
5840 }
5841 
5842 inline void Statement::ClearBinds() const
5843 {
5844  BindsHolder *bindsHolder = GetBindsHolder(false);
5845 
5846  if (bindsHolder)
5847  {
5848  bindsHolder->Clear();
5849  }
5850 }
5851 
5852 inline void Statement::SetOutData() const
5853 {
5854  BindsHolder *bindsHolder = GetBindsHolder(false);
5855 
5856  if (bindsHolder)
5857  {
5858  bindsHolder->SetOutData();
5859  }
5860 }
5861 
5862 inline void Statement::SetInData() const
5863 {
5864  BindsHolder *bindsHolder = GetBindsHolder(false);
5865 
5866  if (bindsHolder)
5867  {
5868  bindsHolder->SetInData();
5869  }
5870 }
5871 
5872 inline void Statement::ReleaseResultsets() const
5873 {
5874  if (_smartHandle)
5875  {
5876  Handle *handle = nullptr;
5877 
5878  while (_smartHandle->GetChildren().FindIf(IsResultsetHandle, handle))
5879  {
5880  if (handle)
5881  {
5882  handle->DetachFromHolders();
5883 
5884  delete handle;
5885 
5886  handle = nullptr;
5887  }
5888  }
5889  }
5890 }
5891 
5892 inline bool Statement::IsResultsetHandle(Handle *handle)
5893 {
5894  Resultset::SmartHandle *smartHandle = dynamic_cast<Resultset::SmartHandle *>(handle);
5895 
5896  return smartHandle != nullptr;
5897 }
5898 
5899 inline void Statement::OnFreeSmartHandle(SmartHandle *smartHandle)
5900 {
5901  if (smartHandle)
5902  {
5903  BindsHolder *bindsHolder = static_cast<BindsHolder *>(smartHandle->GetExtraInfos());
5904 
5905  smartHandle->SetExtraInfos(nullptr);
5906 
5907  delete bindsHolder;
5908  }
5909 }
5910 
5911 inline void Statement::SetLastBindMode(BindInfo::BindDirection mode)
5912 {
5914 }
5915 
5916 inline BindsHolder * Statement::GetBindsHolder(bool create) const
5917 {
5918  BindsHolder * bindsHolder = static_cast<BindsHolder *>(_smartHandle->GetExtraInfos());
5919 
5920  if (bindsHolder == nullptr && create)
5921  {
5922  bindsHolder = new BindsHolder(*this);
5923  _smartHandle->SetExtraInfos(bindsHolder);
5924  }
5925 
5926  return bindsHolder;
5927 }
5928 
5929 /* --------------------------------------------------------------------------------------------- *
5930  * Resultset
5931  * --------------------------------------------------------------------------------------------- */
5932 
5933 inline Resultset::Resultset(OCI_Resultset *resultset, Handle *parent)
5934 {
5935  Acquire(resultset, nullptr, nullptr, parent);
5936 }
5937 
5938 inline bool Resultset::Next()
5939 {
5940  return (Check(OCI_FetchNext(*this)) == TRUE);
5941 }
5942 
5943 inline bool Resultset::Prev()
5944 {
5945  return (Check(OCI_FetchPrev(*this)) == TRUE);
5946 }
5947 
5948 inline bool Resultset::First()
5949 {
5950  return (Check(OCI_FetchFirst(*this)) == TRUE);
5951 }
5952 
5953 inline bool Resultset::Last()
5954 {
5955  return (Check(OCI_FetchLast(*this)) == TRUE);
5956 }
5957 
5958 inline bool Resultset::Seek(SeekMode mode, int offset)
5959 {
5960  return (Check(OCI_FetchSeek(*this, mode, offset)) == TRUE);
5961 }
5962 
5963 inline unsigned int Resultset::GetCount() const
5964 {
5965  return Check(OCI_GetRowCount(*this));
5966 }
5967 
5968 inline unsigned int Resultset::GetCurrentRow() const
5969 {
5970  return Check(OCI_GetCurrentRow(*this));
5971 }
5972 
5973 inline unsigned int Resultset::GetColumnIndex(const ostring& name) const
5974 {
5975  return Check(OCI_GetColumnIndex(*this, name.c_str()));
5976 }
5977 
5978 inline unsigned int Resultset::GetColumnCount() const
5979 {
5980  return Check(OCI_GetColumnCount(*this));
5981 }
5982 
5983 inline Column Resultset::GetColumn(unsigned int index) const
5984 {
5985  return Column(Check(OCI_GetColumn(*this, index)), GetHandle());
5986 }
5987 
5988 inline Column Resultset::GetColumn(const ostring& name) const
5989 {
5990  return Column(Check(OCI_GetColumn2(*this, name.c_str())), GetHandle());
5991 }
5992 
5993 inline bool Resultset::IsColumnNull(unsigned int index) const
5994 {
5995  return (Check(OCI_IsNull(*this, index)) == TRUE);
5996 }
5997 
5998 inline bool Resultset::IsColumnNull(const ostring& name) const
5999 {
6000  return (Check(OCI_IsNull2(*this, name.c_str())) == TRUE);
6001 }
6002 
6003 inline Statement Resultset::GetStatement() const
6004 {
6005  return Statement( Check(OCI_ResultsetGetStatement(*this)), nullptr);
6006 }
6007 
6008 inline bool Resultset::operator ++ (int)
6009 {
6010  return Next();
6011 }
6012 
6013 inline bool Resultset::operator -- (int)
6014 {
6015  return Prev();
6016 }
6017 
6018 inline bool Resultset::operator += (int offset)
6019 {
6020  return Seek(SeekRelative, offset);
6021 }
6022 
6023 inline bool Resultset::operator -= (int offset)
6024 {
6025  return Seek(SeekRelative, -offset);
6026 }
6027 
6028 template<class T>
6029 void Resultset::Get(unsigned int index, T& value) const
6030 {
6031  value = Get<T>(index);
6032 }
6033 
6034 template<class T>
6035 void Resultset::Get(const ostring &name, T& value) const
6036 {
6037  value = Get<T>(name);
6038 }
6039 
6040 template<class T, class TAdapter>
6041 bool Resultset::Get(T& value, TAdapter adapter) const
6042 {
6043  return adapter(static_cast<const Resultset&>(*this), value);
6044 }
6045 
6046 template<class TCallback>
6047 unsigned int Resultset::ForEach(TCallback callback)
6048 {
6049  while (Next())
6050  {
6051  if (!callback(static_cast<const Resultset&>(*this)))
6052  {
6053  break;
6054  }
6055  }
6056 
6057  return GetCurrentRow();
6058 }
6059 
6060 template<class T, class U>
6061 unsigned int Resultset::ForEach(T callback, U adapter)
6062 {
6063  while (Next())
6064  {
6065  if (!callback(adapter(static_cast<const Resultset&>(*this))))
6066  {
6067  break;
6068  }
6069  }
6070 
6071  return GetCurrentRow();
6072 }
6073 
6074 template<>
6075 inline short Resultset::Get<short>(unsigned int index) const
6076 {
6077  return Check(OCI_GetShort(*this, index));
6078 }
6079 
6080 template<>
6081 inline short Resultset::Get<short>(const ostring& name) const
6082 {
6083  return Check(OCI_GetShort2(*this, name.c_str()));
6084 }
6085 
6086 template<>
6087 inline unsigned short Resultset::Get<unsigned short>(unsigned int index) const
6088 {
6089  return Check(OCI_GetUnsignedShort(*this, index));
6090 }
6091 
6092 template<>
6093 inline unsigned short Resultset::Get<unsigned short>(const ostring& name) const
6094 {
6095  return Check(OCI_GetUnsignedShort2(*this, name.c_str()));
6096 }
6097 
6098 template<>
6099 inline int Resultset::Get<int>(unsigned int index) const
6100 {
6101  return Check(OCI_GetInt(*this, index));
6102 }
6103 
6104 template<>
6105 inline int Resultset::Get<int>(const ostring& name) const
6106 {
6107  return Check(OCI_GetInt2(*this, name.c_str()));
6108 }
6109 
6110 template<>
6111 inline unsigned int Resultset::Get<unsigned int>(unsigned int index) const
6112 {
6113  return Check(OCI_GetUnsignedInt(*this, index));
6114 }
6115 
6116 template<>
6117 inline unsigned int Resultset::Get<unsigned int>(const ostring& name) const
6118 {
6119  return Check(OCI_GetUnsignedInt2(*this, name.c_str()));
6120 }
6121 
6122 template<>
6123 inline big_int Resultset::Get<big_int>(unsigned int index) const
6124 {
6125  return Check(OCI_GetBigInt(*this, index));
6126 }
6127 
6128 template<>
6129 inline big_int Resultset::Get<big_int>(const ostring& name) const
6130 {
6131  return Check(OCI_GetBigInt2(*this, name.c_str()));
6132 }
6133 
6134 template<>
6135 inline big_uint Resultset::Get<big_uint>(unsigned int index) const
6136 {
6137  return Check(OCI_GetUnsignedBigInt(*this, index));
6138 }
6139 
6140 template<>
6141 inline big_uint Resultset::Get<big_uint>(const ostring& name) const
6142 {
6143  return Check(OCI_GetUnsignedBigInt2(*this, name.c_str()));
6144 }
6145 
6146 template<>
6147 inline float Resultset::Get<float>(unsigned int index) const
6148 {
6149  return Check(OCI_GetFloat(*this, index));
6150 }
6151 
6152 template<>
6153 inline float Resultset::Get<float>(const ostring& name) const
6154 {
6155  return Check(OCI_GetFloat2(*this, name.c_str()));
6156 }
6157 
6158 template<>
6159 inline double Resultset::Get<double>(unsigned int index) const
6160 {
6161  return Check(OCI_GetDouble(*this, index));
6162 }
6163 
6164 template<>
6165 inline double Resultset::Get<double>(const ostring& name) const
6166 {
6167  return Check(OCI_GetDouble2(*this, name.c_str()));
6168 }
6169 
6170 template<>
6171 inline Number Resultset::Get<Number>(unsigned int index) const
6172 {
6173  return Number(Check(OCI_GetNumber(*this, index)), GetHandle());
6174 }
6175 
6176 template<>
6177 inline Number Resultset::Get<Number>(const ostring& name) const
6178 {
6179  return Number(Check(OCI_GetNumber2(*this, name.c_str())), GetHandle());
6180 }
6181 
6182 template<>
6183 inline ostring Resultset::Get<ostring>(unsigned int index) const
6184 {
6185  return MakeString(Check(OCI_GetString(*this, index)));
6186 }
6187 
6188 template<>
6189 inline ostring Resultset::Get<ostring>(const ostring& name) const
6190 {
6191  return MakeString(Check(OCI_GetString2(*this,name.c_str())));
6192 }
6193 
6194 template<>
6195 inline Raw Resultset::Get<Raw>(unsigned int index) const
6196 {
6197  unsigned int size = Check(OCI_GetDataLength(*this,index));
6198 
6199  ManagedBuffer<unsigned char> buffer(size + 1);
6200 
6201  size = Check(OCI_GetRaw(*this, index, static_cast<AnyPointer>(buffer), size));
6202 
6203  return MakeRaw(buffer, size);
6204 }
6205 
6206 template<>
6207 inline Raw Resultset::Get<Raw>(const ostring& name) const
6208 {
6209  unsigned int size = Check(OCI_GetDataLength(*this, Check(OCI_GetColumnIndex(*this, name.c_str()))));
6210 
6211  ManagedBuffer<unsigned char> buffer(size + 1);
6212 
6213  size = Check(OCI_GetRaw2(*this, name.c_str(), static_cast<AnyPointer>(buffer), size));
6214 
6215  return MakeRaw(buffer, size);
6216 }
6217 
6218 template<>
6219 inline Date Resultset::Get<Date>(unsigned int index) const
6220 {
6221  return Date(Check(OCI_GetDate(*this, index)), GetHandle());
6222 }
6223 
6224 template<>
6225 inline Date Resultset::Get<Date>(const ostring& name) const
6226 {
6227  return Date(Check(OCI_GetDate2(*this,name.c_str())), GetHandle());
6228 }
6229 
6230 template<>
6231 inline Timestamp Resultset::Get<Timestamp>(unsigned int index) const
6232 {
6233  return Timestamp(Check(OCI_GetTimestamp(*this, index)), GetHandle());
6234 }
6235 
6236 template<>
6237 inline Timestamp Resultset::Get<Timestamp>(const ostring& name) const
6238 {
6239  return Timestamp(Check(OCI_GetTimestamp2(*this,name.c_str())), GetHandle());
6240 }
6241 
6242 template<>
6243 inline Interval Resultset::Get<Interval>(unsigned int index) const
6244 {
6245  return Interval(Check(OCI_GetInterval(*this, index)), GetHandle());
6246 }
6247 
6248 template<>
6249 inline Interval Resultset::Get<Interval>(const ostring& name) const
6250 {
6251  return Interval(Check(OCI_GetInterval2(*this,name.c_str())), GetHandle());
6252 }
6253 
6254 template<>
6255 inline Object Resultset::Get<Object>(unsigned int index) const
6256 {
6257  return Object(Check(OCI_GetObject(*this, index)), GetHandle());
6258 }
6259 
6260 template<>
6261 inline Object Resultset::Get<Object>(const ostring& name) const
6262 {
6263  return Object(Check(OCI_GetObject2(*this,name.c_str())), GetHandle());
6264 }
6265 
6266 template<>
6267 inline Reference Resultset::Get<Reference>(unsigned int index) const
6268 {
6269  return Reference(Check(OCI_GetRef(*this, index)), GetHandle());
6270 }
6271 
6272 template<>
6273 inline Reference Resultset::Get<Reference>(const ostring& name) const
6274 {
6275  return Reference(Check(OCI_GetRef2(*this,name.c_str())), GetHandle());
6276 }
6277 
6278 template<>
6279 inline Statement Resultset::Get<Statement>(unsigned int index) const
6280 {
6281  return Statement(Check(OCI_GetStatement(*this, index)), GetHandle());
6282 }
6283 
6284 template<>
6285 inline Statement Resultset::Get<Statement>(const ostring& name) const
6286 {
6287  return Statement(Check(OCI_GetStatement2(*this,name.c_str())), GetHandle());
6288 }
6289 
6290 template<>
6291 inline Clob Resultset::Get<Clob>(unsigned int index) const
6292 {
6293  return Clob(Check(OCI_GetLob(*this, index)), GetHandle());
6294 }
6295 
6296 template<>
6297 inline Clob Resultset::Get<Clob>(const ostring& name) const
6298 {
6299  return Clob(Check(OCI_GetLob2(*this,name.c_str())), GetHandle());
6300 }
6301 
6302 template<>
6303 inline NClob Resultset::Get<NClob>(unsigned int index) const
6304 {
6305  return NClob(Check(OCI_GetLob(*this, index)), GetHandle());
6306 }
6307 
6308 template<>
6309 inline NClob Resultset::Get<NClob>(const ostring& name) const
6310 {
6311  return NClob(Check(OCI_GetLob2(*this, name.c_str())), GetHandle());
6312 }
6313 
6314 template<>
6315 inline Blob Resultset::Get<Blob>(unsigned int index) const
6316 {
6317  return Blob(Check(OCI_GetLob(*this, index)), GetHandle());
6318 }
6319 
6320 template<>
6321 inline Blob Resultset::Get<Blob>(const ostring& name) const
6322 {
6323  return Blob(Check(OCI_GetLob2(*this,name.c_str())), GetHandle());
6324 }
6325 
6326 template<>
6327 inline File Resultset::Get<File>(unsigned int index) const
6328 {
6329  return File(Check(OCI_GetFile(*this, index)), GetHandle());
6330 }
6331 
6332 template<>
6333 inline File Resultset::Get<File>(const ostring& name) const
6334 {
6335  return File(Check(OCI_GetFile2(*this,name.c_str())), GetHandle());
6336 }
6337 
6338 template<>
6339 inline Clong Resultset::Get<Clong>(unsigned int index) const
6340 {
6341  return Clong(Check(OCI_GetLong(*this, index)), GetHandle());
6342 }
6343 
6344 template<>
6345 inline Clong Resultset::Get<Clong>(const ostring& name) const
6346 {
6347  return Clong(Check(OCI_GetLong2(*this,name.c_str())), GetHandle());
6348 }
6349 
6350 template<>
6351 inline Blong Resultset::Get<Blong>(unsigned int index) const
6352 {
6353  return Blong(Check(OCI_GetLong(*this, index)), GetHandle());
6354 }
6355 
6356 template<>
6357 inline Blong Resultset::Get<Blong>(const ostring& name) const
6358 {
6359  return Blong(Check(OCI_GetLong2(*this,name.c_str())), GetHandle());
6360 }
6361 
6362 template<class T>
6363 T Resultset::Get(unsigned int index) const
6364 {
6365  return T(Check(OCI_GetColl(*this, index)), GetHandle());
6366 }
6367 
6368 template<class T>
6369 T Resultset::Get(const ostring& name) const
6370 {
6371  return T(Check(OCI_GetColl2(*this, name.c_str())), GetHandle());
6372 }
6373 
6374 /* --------------------------------------------------------------------------------------------- *
6375  * Column
6376  * --------------------------------------------------------------------------------------------- */
6377 
6378 inline Column::Column(OCI_Column *pColumn, Handle *parent)
6379 {
6380  Acquire(pColumn, nullptr, nullptr, parent);
6381 }
6382 
6383 inline ostring Column::GetName() const
6384 {
6385  return MakeString(Check(OCI_ColumnGetName(*this)));
6386 }
6387 
6388 inline ostring Column::GetSQLType() const
6389 {
6390  return MakeString(Check(OCI_ColumnGetSQLType(*this)));
6391 }
6392 
6393 inline ostring Column::GetFullSQLType() const
6394 {
6395  unsigned int size = OCI_SIZE_BUFFER;
6396 
6397  ManagedBuffer<otext> buffer(size + 1);
6398 
6399  Check(OCI_ColumnGetFullSQLType(*this, buffer, size));
6400 
6401  return MakeString(static_cast<const otext *>(buffer));
6402 }
6403 
6405 {
6406  return DataType(static_cast<DataType::Type>(Check(OCI_ColumnGetType(*this))));
6407 }
6408 
6409 inline unsigned int Column::GetSubType() const
6410 {
6411  return Check(OCI_ColumnGetSubType(*this));
6412 }
6413 
6415 {
6416  return CharsetForm(static_cast<CharsetForm::Type>(Check(OCI_ColumnGetCharsetForm(*this))));
6417 }
6418 
6419 inline unsigned int Column::GetSize() const
6420 {
6421  return Check(OCI_ColumnGetSize(*this));
6422 }
6423 
6424 inline int Column::GetScale() const
6425 {
6426  return Check(OCI_ColumnGetScale(*this));
6427 }
6428 
6429 inline int Column::GetPrecision() const
6430 {
6431  return Check(OCI_ColumnGetPrecision(*this));
6432 }
6433 
6435 {
6436  return Check(OCI_ColumnGetFractionalPrecision(*this));
6437 }
6438 
6440 {
6441  return Check(OCI_ColumnGetLeadingPrecision(*this));
6442 }
6443 
6445 {
6446  return PropertyFlags(static_cast<PropertyFlags::Type>(Check(OCI_ColumnGetPropertyFlags(*this))));
6447 }
6448 
6449 inline bool Column::IsNullable() const
6450 {
6451  return (Check(OCI_ColumnGetNullable(*this)) == TRUE);
6452 }
6453 
6454 inline bool Column::IsCharSemanticUsed() const
6455 {
6456  return (Check(OCI_ColumnGetCharUsed(*this)) == TRUE);
6457 }
6458 
6460 {
6461  return TypeInfo(Check(OCI_ColumnGetTypeInfo(*this)));
6462 }
6463 
6464 /* --------------------------------------------------------------------------------------------- *
6465  * Subscription
6466  * --------------------------------------------------------------------------------------------- */
6467 
6469 {
6470 
6471 }
6472 
6473 inline Subscription::Subscription(OCI_Subscription *pSubcription)
6474 {
6475  Acquire(pSubcription, nullptr, nullptr, nullptr);
6476 }
6477 
6478 inline void Subscription::Register(const Connection &connection, const ostring& name, ChangeTypes changeTypes, NotifyHandlerProc handler, unsigned int port, unsigned int timeout)
6479 {
6480  Acquire(Check(OCI_SubscriptionRegister(connection, name.c_str(), changeTypes.GetValues(),
6481  static_cast<POCI_NOTIFY> (handler != nullptr ? Environment::NotifyHandler : nullptr), port, timeout)),
6482  reinterpret_cast<HandleFreeFunc>(OCI_SubscriptionUnregister), nullptr, nullptr);
6483 
6484  Environment::SetUserCallback<Subscription::NotifyHandlerProc>(static_cast<OCI_Subscription*>(*this), handler);
6485 }
6486 
6488 {
6489  Environment::SetUserCallback<Subscription::NotifyHandlerProc>(static_cast<OCI_Subscription*>(*this), nullptr);
6490 
6491  Release();
6492 }
6493 
6494 inline void Subscription::Watch(const ostring& sql)
6495 {
6496  Statement st(GetConnection());
6497 
6498  st.Execute(sql);
6499 
6500  Check(OCI_SubscriptionAddStatement(*this, st));
6501 }
6502 
6503 inline ostring Subscription::GetName() const
6504 {
6505  return MakeString(Check(OCI_SubscriptionGetName(*this)));
6506 }
6507 
6508 inline unsigned int Subscription::GetTimeout() const
6509 {
6510  return Check(OCI_SubscriptionGetTimeout(*this));
6511 }
6512 
6513 inline unsigned int Subscription::GetPort() const
6514 {
6515  return Check(OCI_SubscriptionGetPort(*this));
6516 }
6517 
6519 {
6520  return Connection(Check(OCI_SubscriptionGetConnection(*this)), nullptr);
6521 }
6522 
6523 /* --------------------------------------------------------------------------------------------- *
6524  * Event
6525  * --------------------------------------------------------------------------------------------- */
6526 
6527 inline Event::Event(OCI_Event *pEvent)
6528 {
6529  Acquire(pEvent, nullptr, nullptr, nullptr);
6530 }
6531 
6533 {
6534  return EventType(static_cast<EventType::Type>(Check(OCI_EventGetType(*this))));
6535 }
6536 
6538 {
6539  return ObjectEvent(static_cast<ObjectEvent::Type>(Check(OCI_EventGetOperation(*this))));
6540 }
6541 
6542 inline ostring Event::GetDatabaseName() const
6543 {
6544  return MakeString(Check(OCI_EventGetDatabase(*this)));
6545 }
6546 
6547 inline ostring Event::GetObjectName() const
6548 {
6549  return MakeString(Check(OCI_EventGetObject(*this)));
6550 }
6551 
6552 inline ostring Event::GetRowID() const
6553 {
6554  return MakeString(Check(OCI_EventGetRowid(*this)));
6555 }
6556 
6558 {
6560 }
6561 
6562 /* --------------------------------------------------------------------------------------------- *
6563  * Agent
6564  * --------------------------------------------------------------------------------------------- */
6565 
6566 inline Agent::Agent(const Connection &connection, const ostring& name, const ostring& address)
6567 {
6568  Acquire(Check(OCI_AgentCreate(connection, name.c_str(), address.c_str())), reinterpret_cast<HandleFreeFunc>(OCI_AgentFree), nullptr, nullptr);
6569 }
6570 
6571 inline Agent::Agent(OCI_Agent *pAgent, Handle *parent)
6572 {
6573  Acquire(pAgent, nullptr, nullptr, parent);
6574 }
6575 
6576 inline ostring Agent::GetName() const
6577 {
6578  return MakeString(Check(OCI_AgentGetName(*this)));
6579 }
6580 
6581 inline void Agent::SetName(const ostring& value)
6582 {
6583  Check(OCI_AgentSetName(*this, value.c_str()));
6584 }
6585 
6586 inline ostring Agent::GetAddress() const
6587 {
6588  return MakeString(Check(OCI_AgentGetAddress(*this)));
6589 }
6590 
6591 inline void Agent::SetAddress(const ostring& value)
6592 {
6593  Check(OCI_AgentSetAddress(*this, value.c_str()));
6594 }
6595 
6596 /* --------------------------------------------------------------------------------------------- *
6597  * Message
6598  * --------------------------------------------------------------------------------------------- */
6599 
6600 inline Message::Message(const TypeInfo &typeInfo)
6601 {
6602  Acquire(Check(OCI_MsgCreate(typeInfo)), reinterpret_cast<HandleFreeFunc>(OCI_MsgFree), nullptr, nullptr);
6603 }
6604 
6605 inline Message::Message(OCI_Msg *pMessage, Handle *parent)
6606 {
6607  Acquire(pMessage, nullptr, nullptr, parent);
6608 }
6609 
6610 inline void Message::Reset()
6611 {
6612  Check(OCI_MsgReset(*this));
6613 }
6614 
6615 template<>
6616 inline Object Message::GetPayload<Object>()
6617 {
6618  return Object(Check(OCI_MsgGetObject(*this)), nullptr);
6619 }
6620 
6621 template<>
6622 inline void Message::SetPayload<Object>(const Object &value)
6623 {
6624  Check(OCI_MsgSetObject(*this, value));
6625 }
6626 
6627 template<>
6628 inline Raw Message::GetPayload<Raw>()
6629 {
6630  unsigned int size = 0;
6631 
6632  ManagedBuffer<unsigned char> buffer(size + 1);
6633 
6634  Check(OCI_MsgGetRaw(*this, static_cast<AnyPointer>(buffer), &size));
6635 
6636  return MakeRaw(buffer, size);
6637 }
6638 
6639 template<>
6640 inline void Message::SetPayload<Raw>(const Raw &value)
6641 {
6642  if (value.size() > 0)
6643  {
6644  Check(OCI_MsgSetRaw(*this, static_cast<AnyPointer>(const_cast<Raw::value_type *>(&value[0])), static_cast<unsigned int>(value.size())));
6645  }
6646  else
6647  {
6648  Check(OCI_MsgSetRaw(*this, nullptr, 0));
6649  }
6650 }
6651 
6652 inline Date Message::GetEnqueueTime() const
6653 {
6654  return Date(Check(OCI_MsgGetEnqueueTime(*this)), nullptr);
6655 }
6656 
6657 inline int Message::GetAttemptCount() const
6658 {
6659  return Check(OCI_MsgGetAttemptCount(*this));
6660 }
6661 
6663 {
6664  return MessageState(static_cast<MessageState::Type>(Check(OCI_MsgGetState(*this))));
6665 }
6666 
6667 inline Raw Message::GetID() const
6668 {
6669  unsigned int size = OCI_SIZE_BUFFER;
6670 
6671  ManagedBuffer<unsigned char> buffer(size + 1);
6672 
6673  Check(OCI_MsgGetID(*this, static_cast<AnyPointer>(buffer), &size));
6674 
6675  return MakeRaw(buffer, size);
6676 }
6677 
6678 inline int Message::GetExpiration() const
6679 {
6680  return Check(OCI_MsgGetExpiration(*this));
6681 }
6682 
6683 inline void Message::SetExpiration(int value)
6684 {
6685  Check(OCI_MsgSetExpiration(*this, value));
6686 }
6687 
6688 inline int Message::GetEnqueueDelay() const
6689 {
6690  return Check(OCI_MsgGetEnqueueDelay(*this));
6691 }
6692 
6693 inline void Message::SetEnqueueDelay(int value)
6694 {
6695  Check(OCI_MsgSetEnqueueDelay(*this, value));
6696 }
6697 
6698 inline int Message::GetPriority() const
6699 {
6700  return Check(OCI_MsgGetPriority(*this));
6701 }
6702 
6703 inline void Message::SetPriority(int value)
6704 {
6705  Check(OCI_MsgSetPriority(*this, value));
6706 }
6707 
6708 inline Raw Message::GetOriginalID() const
6709 {
6710  unsigned int size = OCI_SIZE_BUFFER;
6711 
6712  ManagedBuffer<unsigned char> buffer(size + 1);
6713 
6714  Check(OCI_MsgGetOriginalID(*this, static_cast<AnyPointer>(buffer), &size));
6715 
6716  return MakeRaw(buffer, size);
6717 }
6718 
6719 inline void Message::SetOriginalID(const Raw &value)
6720 {
6721  if (value.size() > 0)
6722  {
6723  Check(OCI_MsgSetOriginalID(*this, static_cast<AnyPointer>(const_cast<Raw::value_type *>(&value[0])), static_cast<unsigned int>(value.size())));
6724  }
6725  else
6726  {
6727  Check(OCI_MsgSetOriginalID(*this, nullptr, 0));
6728  }
6729 }
6730 
6731 inline ostring Message::GetCorrelation() const
6732 {
6733  return MakeString(Check(OCI_MsgGetCorrelation(*this)));
6734 }
6735 
6736 inline void Message::SetCorrelation(const ostring& value)
6737 {
6738  Check(OCI_MsgSetCorrelation(*this, value.c_str()));
6739 }
6740 
6741 inline ostring Message::GetExceptionQueue() const
6742 {
6743  return MakeString(Check(OCI_MsgGetExceptionQueue(*this)));
6744 }
6745 
6746 inline void Message::SetExceptionQueue(const ostring& value)
6747 {
6748  Check(OCI_MsgSetExceptionQueue(*this, value.c_str()));
6749 }
6750 
6752 {
6753  return Agent(Check(OCI_MsgGetSender(*this)), nullptr);
6754 }
6755 
6756 inline void Message::SetSender(const Agent &agent)
6757 {
6758  Check(OCI_MsgSetSender(*this, agent));
6759 }
6760 
6761 inline void Message::SetConsumers(std::vector<Agent> &agents)
6762 {
6763  size_t size = agents.size();
6764  ManagedBuffer<OCI_Agent*> buffer(size);
6765 
6766  OCI_Agent ** pAgents = static_cast<OCI_Agent **>(buffer);
6767 
6768  for (size_t i = 0; i < size; ++i)
6769  {
6770  pAgents[i] = static_cast<const Agent &>(agents[i]);
6771  }
6772 
6773  Check(OCI_MsgSetConsumers(*this, pAgents, static_cast<unsigned int>(size)));
6774 }
6775 
6776 /* --------------------------------------------------------------------------------------------- *
6777  * Enqueue
6778  * --------------------------------------------------------------------------------------------- */
6779 
6780 inline Enqueue::Enqueue(const TypeInfo &typeInfo, const ostring& queueName)
6781 {
6782  Acquire(Check(OCI_EnqueueCreate(typeInfo, queueName.c_str())), reinterpret_cast<HandleFreeFunc>(OCI_EnqueueFree), nullptr, nullptr);
6783 }
6784 
6785 inline void Enqueue::Put(const Message &message)
6786 {
6787  Check(OCI_EnqueuePut(*this, message));
6788 }
6789 
6791 {
6792  return EnqueueVisibility(static_cast<EnqueueVisibility::Type>(Check(OCI_EnqueueGetVisibility(*this))));
6793 }
6794 
6796 {
6797  Check(OCI_EnqueueSetVisibility(*this, value));
6798 }
6799 
6801 {
6802  return EnqueueMode(static_cast<EnqueueMode::Type>(Check(OCI_EnqueueGetSequenceDeviation(*this))));
6803 }
6804 
6805 inline void Enqueue::SetMode(EnqueueMode value)
6806 {
6807  Check(OCI_EnqueueSetSequenceDeviation(*this, value));
6808 }
6809 
6810 inline Raw Enqueue::GetRelativeMsgID() const
6811 {
6812  unsigned int size = OCI_SIZE_BUFFER;
6813 
6814  ManagedBuffer<unsigned char> buffer(size + 1);
6815 
6816  Check(OCI_EnqueueGetRelativeMsgID(*this, static_cast<AnyPointer>(buffer), &size));
6817 
6818  return MakeRaw(buffer, size);
6819 }
6820 
6821 inline void Enqueue::SetRelativeMsgID(const Raw &value)
6822 {
6823  if (value.size() > 0)
6824  {
6825  Check(OCI_EnqueueSetRelativeMsgID(*this, static_cast<AnyPointer>(const_cast<Raw::value_type *>(&value[0])), static_cast<unsigned int>(value.size())));
6826  }
6827  else
6828  {
6829  Check(OCI_EnqueueSetRelativeMsgID(*this, nullptr, 0));
6830  }
6831 }
6832 
6833 /* --------------------------------------------------------------------------------------------- *
6834  * Dequeue
6835  * --------------------------------------------------------------------------------------------- */
6836 
6837 inline Dequeue::Dequeue(const TypeInfo &typeInfo, const ostring& queueName)
6838 {
6839  Acquire(Check(OCI_DequeueCreate(typeInfo, queueName.c_str())), reinterpret_cast<HandleFreeFunc>(OCI_DequeueFree), nullptr, nullptr);
6840 }
6841 
6842 inline Dequeue::Dequeue(OCI_Dequeue *pDequeue)
6843 {
6844  Acquire(pDequeue, nullptr, nullptr, nullptr);
6845 }
6846 
6848 {
6849  return Message(Check(OCI_DequeueGet(*this)), nullptr);
6850 }
6851 
6852 inline Agent Dequeue::Listen(int timeout)
6853 {
6854  return Agent(Check(OCI_DequeueListen(*this, timeout)), nullptr);
6855 }
6856 
6857 inline ostring Dequeue::GetConsumer() const
6858 {
6859  return MakeString(Check(OCI_DequeueGetConsumer(*this)));
6860 }
6861 
6862 inline void Dequeue::SetConsumer(const ostring& value)
6863 {
6864  Check(OCI_DequeueSetConsumer(*this, value.c_str()));
6865 }
6866 
6867 inline ostring Dequeue::GetCorrelation() const
6868 {
6869  return MakeString(Check(OCI_DequeueGetCorrelation(*this)));
6870 }
6871 
6872 inline void Dequeue::SetCorrelation(const ostring& value)
6873 {
6874  Check(OCI_DequeueSetCorrelation(*this, value.c_str()));
6875 }
6876 
6877 inline Raw Dequeue::GetRelativeMsgID() const
6878 {
6879  unsigned int size = OCI_SIZE_BUFFER;
6880 
6881  ManagedBuffer<unsigned char> buffer(size + 1);
6882 
6883  Check(OCI_DequeueGetRelativeMsgID(*this, static_cast<AnyPointer>(buffer), &size));
6884 
6885  return MakeRaw(buffer, size);
6886 }
6887 
6888 inline void Dequeue::SetRelativeMsgID(const Raw &value)
6889 {
6890  if (value.size() > 0)
6891  {
6892  Check(OCI_DequeueSetRelativeMsgID(*this, static_cast<AnyPointer>(const_cast<Raw::value_type *>(&value[0])), static_cast<unsigned int>(value.size())));
6893  }
6894  else
6895  {
6896  Check(OCI_DequeueSetRelativeMsgID(*this, nullptr, 0));
6897  }
6898 }
6899 
6901 {
6902  return DequeueVisibility(static_cast<DequeueVisibility::Type>(Check(OCI_DequeueGetVisibility(*this))));
6903 }
6904 
6906 {
6907  Check(OCI_DequeueSetVisibility(*this, value));
6908 }
6909 
6911 {
6912  return DequeueMode(static_cast<DequeueMode::Type>(Check(OCI_DequeueGetMode(*this))));
6913 }
6914 
6915 inline void Dequeue::SetMode(DequeueMode value)
6916 {
6917  Check(OCI_DequeueSetMode(*this, value));
6918 }
6919 
6921 {
6922  return NavigationMode(static_cast<NavigationMode::Type>(Check(OCI_DequeueGetNavigation(*this))));
6923 }
6924 
6926 {
6927  Check(OCI_DequeueSetNavigation(*this, value));
6928 }
6929 
6930 inline int Dequeue::GetWaitTime() const
6931 {
6932  return Check(OCI_DequeueGetWaitTime(*this));
6933 }
6934 
6935 inline void Dequeue::SetWaitTime(int value)
6936 {
6937  Check(OCI_DequeueSetWaitTime(*this, value));
6938 }
6939 
6940 inline void Dequeue::SetAgents(std::vector<Agent> &agents)
6941 {
6942  size_t size = agents.size();
6943  ManagedBuffer<OCI_Agent*> buffer(size);
6944 
6945  OCI_Agent ** pAgents = static_cast<OCI_Agent **>(buffer);
6946 
6947  for (size_t i = 0; i < size; ++i)
6948  {
6949  pAgents[i] = static_cast<const Agent &>(agents[i]);
6950  }
6951 
6952  Check(OCI_DequeueSetAgentList(*this, pAgents, static_cast<unsigned int>(size)));
6953 }
6954 
6955 inline void Dequeue::Subscribe(unsigned int port, unsigned int timeout, NotifyAQHandlerProc handler)
6956 {
6957  Check(OCI_DequeueSubscribe(*this, port, timeout, static_cast<POCI_NOTIFY_AQ>(handler != nullptr ? Environment::NotifyHandlerAQ : nullptr)));
6958 
6959  Environment::SetUserCallback<NotifyAQHandlerProc>(static_cast<OCI_Dequeue*>(*this), handler);
6960 }
6961 
6963 {
6964  Check(OCI_DequeueUnsubscribe(*this));
6965 }
6966 
6967 /* --------------------------------------------------------------------------------------------- *
6968  * DirectPath
6969  * --------------------------------------------------------------------------------------------- */
6970 
6971 inline DirectPath::DirectPath(const TypeInfo &typeInfo, unsigned int nbCols, unsigned int nbRows, const ostring& partition)
6972 {
6973  Acquire(Check(OCI_DirPathCreate(typeInfo, partition.c_str(), nbCols, nbRows)), reinterpret_cast<HandleFreeFunc>(OCI_DirPathFree), nullptr, nullptr);
6974 }
6975 
6976 inline void DirectPath::SetColumn(unsigned int colIndex, const ostring& name, unsigned int maxSize, const ostring& format)
6977 {
6978  Check(OCI_DirPathSetColumn(*this, colIndex, name.c_str(), maxSize, format.c_str()));
6979 }
6980 
6981 template<class T>
6982 inline void DirectPath::SetEntry(unsigned int rowIndex, unsigned int colIndex, const T &value, bool complete)
6983 {
6984  Check(OCI_DirPathSetEntry(*this, rowIndex, colIndex, static_cast<const AnyPointer>(const_cast<typename T::value_type *>(value.c_str())), static_cast<unsigned int>(value.size()), complete));
6985 }
6986 
6987 inline void DirectPath::Reset()
6988 {
6989  Check(OCI_DirPathReset(*this));
6990 }
6991 
6992 inline void DirectPath::Prepare()
6993 {
6994  Check(OCI_DirPathPrepare(*this));
6995 }
6996 
6998 {
6999  return Result(static_cast<Result::Type>(Check(OCI_DirPathConvert(*this))));
7000 }
7001 
7003 {
7004  return Result(static_cast<Result::Type>(Check(OCI_DirPathLoad(*this))));
7005 }
7006 
7007 inline void DirectPath::Finish()
7008 {
7009  Check(OCI_DirPathFinish(*this));
7010 }
7011 
7012 inline void DirectPath::Abort()
7013 {
7014  Check(OCI_DirPathAbort(*this));
7015 }
7016 
7017 inline void DirectPath::Save()
7018 {
7019  Check(OCI_DirPathSave(*this));
7020 }
7021 
7023 {
7024  Check(OCI_DirPathFlushRow(*this));
7025 }
7026 
7027 inline void DirectPath::SetCurrentRows(unsigned int value)
7028 {
7029  Check(OCI_DirPathSetCurrentRows(*this, value));
7030 }
7031 
7032 inline unsigned int DirectPath::GetCurrentRows() const
7033 {
7034  return Check(OCI_DirPathGetCurrentRows(*this));
7035 }
7036 
7037 inline unsigned int DirectPath::GetMaxRows() const
7038 {
7039  return Check(OCI_DirPathGetMaxRows(*this));
7040 }
7041 
7042 inline unsigned int DirectPath::GetRowCount() const
7043 {
7044  return Check(OCI_DirPathGetRowCount(*this));
7045 }
7046 
7047 inline unsigned int DirectPath::GetAffectedRows() const
7048 {
7049  return Check(OCI_DirPathGetAffectedRows(*this));
7050 }
7051 
7052 inline void DirectPath::SetDateFormat(const ostring& format)
7053 {
7054  Check(OCI_DirPathSetDateFormat(*this, format.c_str()));
7055 }
7056 
7057 inline void DirectPath::SetParallel(bool value)
7058 {
7059  Check(OCI_DirPathSetParallel(*this, value));
7060 }
7061 
7062 inline void DirectPath::SetNoLog(bool value)
7063 {
7064  Check(OCI_DirPathSetNoLog(*this, value));
7065 }
7066 
7067 inline void DirectPath::SetCacheSize(unsigned int value)
7068 {
7069  Check(OCI_DirPathSetCacheSize(*this, value));
7070 }
7071 
7072 inline void DirectPath::SetBufferSize(unsigned int value)
7073 {
7074  Check(OCI_DirPathSetBufferSize(*this, value));
7075 }
7076 
7078 {
7079  Check(OCI_DirPathSetConvertMode(*this, value));
7080 }
7081 
7082 inline unsigned int DirectPath::GetErrorColumn()
7083 {
7084  return Check(OCI_DirPathGetErrorColumn(*this));
7085 }
7086 
7087 inline unsigned int DirectPath::GetErrorRow()
7088 {
7089  return Check(OCI_DirPathGetErrorRow(*this));
7090 }
7091 
7092 /* --------------------------------------------------------------------------------------------- *
7093  * Queue
7094  * --------------------------------------------------------------------------------------------- */
7095 
7096 inline void Queue::Create(const Connection &connection, const ostring& queue, const ostring& table, QueueType queueType, unsigned int maxRetries,
7097  unsigned int retryDelay, unsigned int retentionTime, bool dependencyTracking, const ostring& comment)
7098 {
7099  Check(OCI_QueueCreate(connection, queue.c_str(), table.c_str(), queueType, maxRetries, retryDelay, retentionTime, dependencyTracking, comment.c_str()));
7100 }
7101 
7102 inline void Queue::Alter(const Connection &connection, const ostring& queue, unsigned int maxRetries, unsigned int retryDelay, unsigned int retentionTime, const ostring& comment)
7103 {
7104  Check(OCI_QueueAlter(connection, queue.c_str(), maxRetries, retryDelay, retentionTime, comment.c_str()));
7105 }
7106 
7107 inline void Queue::Drop(const Connection &connection, const ostring& queue)
7108 {
7109  Check(OCI_QueueDrop(connection, queue.c_str()));
7110 }
7111 
7112 inline void Queue::Start(const Connection &connection, const ostring& queue, bool enableEnqueue, bool enableDequeue)
7113 {
7114  Check(OCI_QueueStart(connection, queue.c_str(), enableEnqueue, enableDequeue));
7115 }
7116 
7117 inline void Queue::Stop(const Connection &connection, const ostring& queue, bool stopEnqueue, bool stopDequeue, bool wait)
7118 {
7119  Check(OCI_QueueStop(connection, queue.c_str(), stopEnqueue, stopDequeue, wait));
7120 }
7121 
7122 /* --------------------------------------------------------------------------------------------- *
7123  * QueueTable
7124  * --------------------------------------------------------------------------------------------- */
7125 
7126 inline void QueueTable::Create(const Connection &connection, const ostring& table, const ostring& payloadType, bool multipleConsumers, const ostring& storageClause, const ostring& sortList,
7127  GroupingMode groupingMode, const ostring& comment, unsigned int primaryInstance, unsigned int secondaryInstance, const ostring& compatible)
7128 
7129 {
7130  Check(OCI_QueueTableCreate(connection, table.c_str(), payloadType.c_str(), storageClause.c_str(), sortList.c_str(), multipleConsumers,
7131  groupingMode, comment.c_str(), primaryInstance, secondaryInstance, compatible.c_str()));
7132 }
7133 
7134 inline void QueueTable::Alter(const Connection &connection, const ostring& table, const ostring& comment, unsigned int primaryInstance, unsigned int secondaryInstance)
7135 {
7136  Check(OCI_QueueTableAlter(connection, table.c_str(), comment.c_str(), primaryInstance, secondaryInstance));
7137 }
7138 
7139 inline void QueueTable::Drop(const Connection &connection, const ostring& table, bool force)
7140 {
7141  Check(OCI_QueueTableDrop(connection, table.c_str(), force));
7142 }
7143 
7144 inline void QueueTable::Purge(const Connection &connection, const ostring& table, PurgeMode mode, const ostring& condition, bool block)
7145 {
7146  Check(OCI_QueueTablePurge(connection, table.c_str(), condition.c_str(), block, static_cast<unsigned int>(mode)));
7147 }
7148 
7149 inline void QueueTable::Migrate(const Connection &connection, const ostring& table, const ostring& compatible)
7150 {
7151  Check(OCI_QueueTableMigrate(connection, table.c_str(), compatible.c_str()));
7152 }
7153 
7158 }
OCI_EXPORT OCI_Subscription *OCI_API OCI_EventGetSubscription(OCI_Event *event)
Return the subscription handle that generated this event.
Object()
Create an empty null Object instance.
TimestampType GetType() const
Return the type of the given timestamp object.
OCI_EXPORT boolean OCI_API OCI_ObjectSetFile(OCI_Object *obj, const otext *attr, OCI_File *value)
Set an object attribute of type File.
unsigned int GetAffectedRows() const
Return the number of rows affected by the SQL statement.
OCI_EXPORT boolean OCI_API OCI_BindUnsignedBigInt(OCI_Statement *stmt, const otext *name, big_uint *data)
Bind an unsigned big integer variable.
struct OCI_Agent OCI_Agent
OCILIB encapsulation of A/Q Agent.
Definition: ocilib.h:759
OCI_EXPORT unsigned int OCI_API OCI_GetLongMode(OCI_Statement *stmt)
Return the long data type handling mode of a SQL statement.
OCI_EXPORT unsigned int OCI_API OCI_EnqueueGetVisibility(OCI_Enqueue *enqueue)
Get the enqueuing/locking behavior.
OCI_EXPORT OCI_Column *OCI_API OCI_GetColumn(OCI_Resultset *rs, unsigned int index)
Return the column object handle at the given index in the resultset.
bool operator>(const Timestamp &other) const
Indicates if the current Timestamp value is superior to the given Timestamp value.
Interval operator-(const Interval &other) const
Return a new Interval holding the difference of the current Interval value and the given Interval val...
unsigned int GetLongMaxSize() const
Return the LONG data type piece buffer size.
Encapsulate a Resultset column or object member properties.
Definition: ocilib.hpp:6771
BindDirection GetDirection() const
Get the direction mode.
OCI_EXPORT int OCI_API OCI_ErrorGetInternalCode(OCI_Error *err)
Retrieve Internal Error code from error handle.
OCI_EXPORT big_int OCI_API OCI_ElemGetBigInt(OCI_Elem *elem)
Return the big int value of the given collection element.
void SetHours(int value)
Set the interval hours value.
OCI_EXPORT const otext *OCI_API OCI_GetVersionServer(OCI_Connection *con)
Return the connected database server version.
OCI_EXPORT boolean OCI_API OCI_DateLastDay(OCI_Date *date)
Place the last day of month (from the given date) into the given date.
unsigned int GetSubType() const
Return the OCILIB object subtype of a column.
OCI_EXPORT boolean OCI_API OCI_MsgGetID(OCI_Msg *msg, void *id, unsigned int *len)
Return the ID of the message.
Agent Listen(int timeout)
Listen for messages that match any recipient of the associated Agent list.
OCI_EXPORT big_uint OCI_API OCI_GetAllocatedBytes(unsigned int mem_type)
Return the current number of bytes allocated internally in the library.
OCI_EXPORT boolean OCI_API OCI_ConnectionFree(OCI_Connection *con)
Close a physical connection to an Oracle database server.
unsigned int GetColumnCount() const
Return the number of columns in the resultset.
Lob< Raw, LobBinary > Blob
Class handling BLOB oracle type.
Definition: ocilib.hpp:4324
OCI_EXPORT boolean OCI_API OCI_QueueStart(OCI_Connection *con, const otext *queue_name, boolean enqueue, boolean dequeue)
Start the given queue.
bool operator<(const Date &other) const
Indicates if the current date value is inferior to the given date value.
OCI_EXPORT boolean OCI_API OCI_DequeueSubscribe(OCI_Dequeue *dequeue, unsigned int port, unsigned int timeout, POCI_NOTIFY_AQ callback)
Subscribe for asynchronous messages notifications.
OCI_EXPORT const otext *OCI_API OCI_ServerGetOutput(OCI_Connection *con)
Retrieve one line of the server buffer.
ostring GetRowID() const
Return the rowid of the altered database object row.
OCI_EXPORT boolean OCI_API OCI_ColumnGetCharUsed(OCI_Column *col)
Return TRUE if the length of the column is character-length or FALSE if it is byte-length.
OCI_EXPORT boolean OCI_API OCI_SubscriptionUnregister(OCI_Subscription *sub)
Unregister a previously registered notification.
STL compliant Collection Random iterator class.
Definition: ocilib.hpp:4931
OCI_EXPORT unsigned int OCI_API OCI_LobGetType(OCI_Lob *lob)
Return the type of the given Lob object.
void Open(const ostring &db, const ostring &user, const ostring &pwd, Pool::PoolType poolType, unsigned int minSize, unsigned int maxSize, unsigned int increment=1, Environment::SessionFlags sessionFlags=Environment::SessionDefault)
Create an Oracle pool of connections or sessions.
static void Initialize(EnvironmentFlags mode=Environment::Default, const ostring &libpath=OTEXT(""))
Initialize the OCILIB environment.
OCI_EXPORT boolean OCI_API OCI_CollClear(OCI_Coll *coll)
clear all items of the given collection
bool IsValid() const
Check if the given date is valid.
OCI_EXPORT boolean OCI_API OCI_BindSetNullAtPos(OCI_Bind *bnd, unsigned int position)
Set to null the entry in the bind variable input array.
OCI_EXPORT OCI_Object *OCI_API OCI_ObjectCreate(OCI_Connection *con, OCI_TypeInfo *typinf)
Create a local object instance.
Timestamp & operator-=(int value)
Decrement the Timestamp by the given number of days.
OCI_EXPORT unsigned int OCI_API OCI_MsgGetState(OCI_Msg *msg)
Return the state of the message at the time of the dequeue.
OCI_EXPORT boolean OCI_API OCI_ElemSetNull(OCI_Elem *elem)
Set a collection element value to null.
OCI_EXPORT boolean OCI_API OCI_ObjectSetLob(OCI_Object *obj, const otext *attr, OCI_Lob *value)
Set an object attribute of type Lob.
unsigned int GetCurrentRow() const
Retrieve the current row index.
OCI_EXPORT boolean OCI_API OCI_ExecuteStmt(OCI_Statement *stmt, const otext *sql)
Prepare and Execute a SQL statement or PL/SQL block.
OCI_EXPORT boolean OCI_API OCI_ObjectSetNull(OCI_Object *obj, const otext *attr)
Set an object attribute to null.
OCI_EXPORT OCI_Column *OCI_API OCI_GetColumn2(OCI_Resultset *rs, const otext *name)
Return the column object handle from its name in the resultset.
int GetYear() const
Return the timestamp year value.
OCI_EXPORT boolean OCI_API OCI_DateAddDays(OCI_Date *date, int nb)
Add or subtract days to a date handle.
OCI_EXPORT boolean OCI_API OCI_RegisterUnsignedShort(OCI_Statement *stmt, const otext *name)
Register an unsigned short output bind placeholder.
bool operator!=(const Interval &other) const
Indicates if the current Interval value is not equal the given Interval value.
Statement GetStatement() const
Return the statement associated with the bind object.
OCI_EXPORT boolean OCI_API OCI_RegisterUnsignedBigInt(OCI_Statement *stmt, const otext *name)
Register an unsigned big integer output bind placeholder.
Connection GetConnection() const
Return the lob parent connection.
void(* NotifyAQHandlerProc)(Dequeue &dequeue)
User callback for dequeue event notifications.
Definition: ocilib.hpp:7839
unsigned int GetErrorRow()
Return the index of a row which caused an error during data conversion.
void SetCacheSize(unsigned int value)
Set number of elements in the date cache.
OCI_EXPORT boolean OCI_API OCI_EnqueueSetRelativeMsgID(OCI_Enqueue *enqueue, const void *id, unsigned int len)
Set a message identifier to use for enqueuing messages using a sequence deviation.
OCI_EXPORT boolean OCI_API OCI_RegisterFile(OCI_Statement *stmt, const otext *name, unsigned int type)
Register a file output bind placeholder.
void SetTAFHandler(TAFHandlerProc handler)
Set the Transparent Application Failover (TAF) user handler.
OCI_EXPORT unsigned int OCI_API OCI_GetPrefetchSize(OCI_Statement *stmt)
Return the number of rows pre-fetched by OCI Client.
OCI_EXPORT boolean OCI_API OCI_RegisterDate(OCI_Statement *stmt, const otext *name)
Register a date output bind placeholder.
Lob & operator+=(const Lob &other)
Appending the given lob content to the current lob content.
void GetDateTime(int &year, int &month, int &day, int &hour, int &min, int &sec, int &fsec) const
Extract date and time parts.
void SetFetchSize(unsigned int value)
Set the number of rows fetched per internal server fetch call.
bool Delete(unsigned int index) const
Delete the element at the given position in the Nested Table Collection.
static void EnableWarnings(bool value)
Enable or disable Oracle warning notifications.
Interval()
Create an empty null Interval instance.
ostring GetPassword() const
Return the current logged user password.
OCI_EXPORT OCI_Statement *OCI_API OCI_StatementCreate(OCI_Connection *con)
Create a statement object and return its handle.
OCI_EXPORT boolean OCI_API OCI_ServerDisableOutput(OCI_Connection *con)
Disable the server output.
static unsigned int GetCompileRevisionVersion()
Return the revision version number of OCI used for compiling OCILIB.
void SetFetchMode(FetchMode value)
Set the fetch mode of a SQL statement.
OCI_EXPORT boolean OCI_API OCI_BindUnsignedInt(OCI_Statement *stmt, const otext *name, unsigned int *data)
Bind an unsigned integer variable.
OCI_EXPORT boolean OCI_API OCI_RefSetNull(OCI_Ref *ref)
Nullify the given Ref handle.
struct OCI_Connection OCI_Connection
Oracle physical connection.
Definition: ocilib.h:423
OCI_EXPORT int OCI_API OCI_ObjectGetInt(OCI_Object *obj, const otext *attr)
Return the integer value of the given object attribute.
void FromString(const ostring &str, const ostring &format=OTEXT("")) const
Assign to the number object the value provided by the input number time string.
int GetSeconds() const
Return the interval seconds value.
OCI_EXPORT boolean OCI_API OCI_ThreadRun(OCI_Thread *thread, POCI_THREAD proc, void *arg)
Execute the given routine within the given thread object.
Exception class handling all OCILIB errors.
Definition: ocilib.hpp:485
OCI_EXPORT unsigned int OCI_API OCI_GetLongMaxSize(OCI_Statement *stmt)
Return the LONG data type piece buffer size.
File()
Create an empty null File instance.
big_uint GetLength() const
Returns the number of bytes contained in the file.
void SetMinutes(int value)
Set the date minutes value.
OCI_EXPORT boolean OCI_API OCI_BindSetNotNullAtPos(OCI_Bind *bnd, unsigned int position)
Set to NOT null the entry in the bind variable input array.
OCI_EXPORT unsigned int OCI_API OCI_IntervalGetType(OCI_Interval *itv)
Return the type of the given Interval object.
unsigned int GetServerRevisionVersion() const
Return the revision version number of the connected database server.
bool IsCharSemanticUsed() const
Return true if the length of the column is character-length or false if it is byte-length.
Provides SQL bind informations.
Definition: ocilib.hpp:5321
bool IsColumnNull(unsigned int index) const
Check if the current row value is null for the column at the given index.
ostring GetServer() const
Return the Oracle server Hos name of the connected database/service name.
OCI_EXPORT boolean OCI_API OCI_DequeueFree(OCI_Dequeue *dequeue)
Free a Dequeue object.
OCI_EXPORT OCI_Connection *OCI_API OCI_ErrorGetConnection(OCI_Error *err)
Retrieve connection handle within the error occurred.
OCI_EXPORT boolean OCI_API OCI_NumberGetValue(OCI_Number *number, unsigned int type, void *value)
Assign the number value to a native C numeric type.
Date operator+(int value) const
Return a new date holding the current date value incremented by the given number of days...
void SetTrace(SessionTrace trace, const ostring &value)
Set tracing information for the session.
unsigned int GetPort() const
Return the port used by the notification.
OCI_EXPORT boolean OCI_API OCI_FileAssign(OCI_File *file, OCI_File *file_src)
Assign a file to another one.
unsigned int GetCount() const
Returns the current number of elements in the collection.
Resultset GetResultset()
Retrieve the resultset from an executed statement.
OCI_EXPORT boolean OCI_API OCI_DateFromText(OCI_Date *date, const otext *str, const otext *fmt)
Convert a string to a date and store it in the given date handle.
OCI_EXPORT const otext *OCI_API OCI_GetUserName(OCI_Connection *con)
Return the current logged user name.
OCI_EXPORT const otext *OCI_API OCI_ColumnGetSQLType(OCI_Column *col)
Return the Oracle SQL type name of the column data type.
OCI_EXPORT boolean OCI_API OCI_PoolSetStatementCacheSize(OCI_Pool *pool, unsigned int value)
Set the maximum number of statements to keep in the pool statement cache.
void SetCharsetForm(CharsetForm value)
Set the charset form of the given character based bind object.
ostring GetName() const
Return the name of the given registered subscription.
bool Next()
Fetch the next row of the resultset.
OCI_EXPORT boolean OCI_API OCI_DequeueSetWaitTime(OCI_Dequeue *dequeue, int timeout)
set the time that OCIDequeueGet() waits for messages if no messages are currently available ...
void Describe(const ostring &sql)
Describe the select list of a SQL select statement.
void SetNoLog(bool value)
Set the logging mode for the loading operation.
OCI_EXPORT boolean OCI_API OCI_FetchPrev(OCI_Resultset *rs)
Fetch the previous row of the resultset.
int GetSeconds() const
Return the timestamp seconds value.
OCI_EXPORT boolean OCI_API OCI_DequeueSetNavigation(OCI_Dequeue *dequeue, unsigned int position)
Set the position of messages to be retrieved.
OCI_EXPORT boolean OCI_API OCI_IsNull(OCI_Resultset *rs, unsigned int index)
Check if the current row value is null for the column at the given index in the resultset.
OCI_EXPORT unsigned int OCI_API OCI_ElemGetUnsignedInt(OCI_Elem *elem)
Return the unsigned int value of the given collection element.
OCI_EXPORT boolean OCI_API OCI_SetUserPassword(const otext *db, const otext *user, const otext *pwd, const otext *new_pwd)
Change the password of the given user on the given database.
OCI_EXPORT boolean OCI_API OCI_ObjectSetRaw(OCI_Object *obj, const otext *attr, void *value, unsigned int len)
Set an object attribute of type RAW.
ostring GetUserName() const
Return the current logged user name.
OCI_EXPORT const otext *OCI_API OCI_ObjectGetString(OCI_Object *obj, const otext *attr)
Return the string value of the given object attribute.
OCI_EXPORT big_uint OCI_API OCI_LobGetOffset(OCI_Lob *lob)
Return the current position in the Lob content buffer.
OCILIB ++ Namespace.
OCI_EXPORT boolean OCI_API OCI_IntervalSubtract(OCI_Interval *itv, OCI_Interval *itv2)
Subtract an interval handle value from another.
OCI_EXPORT unsigned int OCI_API OCI_ColumnGetFullSQLType(OCI_Column *col, otext *buffer, unsigned int len)
Return the Oracle SQL Full name including precision and size of the column data type.
void SetDefaultLobPrefetchSize(unsigned int value)
Enable or disable prefetching for all LOBs fetched in the connection.
void ChangePassword(const ostring &newPwd)
Change the password of the logged user.
OCI_EXPORT double OCI_API OCI_ObjectGetDouble(OCI_Object *obj, const otext *attr)
Return the double value of the given object attribute.
OCI_EXPORT boolean OCI_API OCI_BindString(OCI_Statement *stmt, const otext *name, otext *data, unsigned int len)
Bind a string variable.
void Set(unsigned int index, const T &value)
Set the collection element value at the given position.
OCI_EXPORT unsigned int OCI_API OCI_ObjectGetType(OCI_Object *obj)
Return the type of an object instance.
ostring GetName() const
Return the name of the bind object.
static void Purge(const Connection &connection, const ostring &table, PurgeMode mode, const ostring &condition=OTEXT(""), bool block=true)
Purge messages from the given queue table.
TypeInfo GetTypeInfo() const
Return the type information object associated to the collection.
static void Alter(const Connection &connection, const ostring &queue, unsigned int maxRetries=0, unsigned int retryDelay=0, unsigned int retentionTime=0, const ostring &comment=OTEXT(""))
Alter the given queue.
int GetMonth() const
Return the timestamp month value.
iterator begin()
Returns an iterator pointing to the first element in the collection.
OCI_EXPORT OCI_Enqueue *OCI_API OCI_EnqueueCreate(OCI_TypeInfo *typinf, const otext *name)
Create a Enqueue object for the given queue.
Enum< CharsetFormValues > CharsetForm
Type of charsetForm.
Definition: ocilib.hpp:355
OCI_EXPORT OCI_Elem *OCI_API OCI_ElemCreate(OCI_TypeInfo *typinf)
Create a local collection element instance based on a collection type descriptor. ...
OCI_EXPORT boolean OCI_API OCI_ElemSetRaw(OCI_Elem *elem, void *value, unsigned int len)
Set a RAW value to a collection element.
OCI_EXPORT const otext *OCI_API OCI_ColumnGetName(OCI_Column *col)
Return the name of the given column.
void FromString(const ostring &str, const ostring &format=OTEXT(""))
Assign to the date object the value provided by the input date time string.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfUnsignedShorts(OCI_Statement *stmt, const otext *name, unsigned short *data, unsigned int nbelem)
Bind an array of unsigned shorts.
Object Clone() const
Clone the current instance to a new one performing deep copy.
OCI_EXPORT int OCI_API OCI_ObjectGetRaw(OCI_Object *obj, const otext *attr, void *value, unsigned int len)
Return the raw attribute value of the given object attribute into the given buffer.
OCI_EXPORT boolean OCI_API OCI_BindArraySetSize(OCI_Statement *stmt, unsigned int size)
Set the input array size for bulk operations.
OCI_EXPORT OCI_File *OCI_API OCI_ElemGetFile(OCI_Elem *elem)
Return the File value of the given collection element.
void Put(const Message &message)
Enqueue a message the on queue associated to the Enqueue object.
OCI_EXPORT OCI_Connection *OCI_API OCI_PoolGetConnection(OCI_Pool *pool, const otext *tag)
Get a connection from the pool.
void SetAutoCommit(bool enabled)
Enable or disable auto commit mode (implicit commits after every SQL execution)
CollectionElement< T > operator[](unsigned int index)
Returns the element at a given position in the collection.
OCI_EXPORT boolean OCI_API OCI_IntervalFromTimeZone(OCI_Interval *itv, const otext *str)
Correct an interval handle value with the given time zone.
OCI_EXPORT unsigned int OCI_API OCI_GetImportMode(void)
Return the Oracle shared library import mode.
OCI_EXPORT unsigned int OCI_API OCI_BindGetDirection(OCI_Bind *bnd)
Get the direction mode of a bind handle.
Long< Raw, LongBinary > Blong
Class handling LONG RAW oracle type.
Definition: ocilib_impl.hpp:60
OCI_EXPORT OCI_Connection *OCI_API OCI_FileGetConnection(OCI_File *file)
Retrieve connection handle from the file handle.
OCI_EXPORT boolean OCI_API OCI_SetBindMode(OCI_Statement *stmt, unsigned int mode)
Set the binding mode of a SQL statement.
OCI_EXPORT boolean OCI_API OCI_ObjectToText(OCI_Object *obj, unsigned int *size, otext *str)
Convert an object handle value to a string.
OCI_EXPORT boolean OCI_API OCI_DequeueSetVisibility(OCI_Dequeue *dequeue, unsigned int visibility)
Set whether the new message is dequeued as part of the current transaction.
OCI_EXPORT OCI_Statement *OCI_API OCI_GetStatement(OCI_Resultset *rs, unsigned int index)
Return the current cursor value (Nested table) of the column at the given index in the resultset...
OCI_EXPORT boolean OCI_API OCI_FileExists(OCI_File *file)
Check if the given file exists on server.
OCI_EXPORT boolean OCI_API OCI_FetchLast(OCI_Resultset *rs)
Fetch the last row of the resultset.
unsigned int GetRow() const
Return the row index which caused an error during statement execution.
OCI_EXPORT boolean OCI_API OCI_BindStatement(OCI_Statement *stmt, const otext *name, OCI_Statement *data)
Bind a Statement variable (PL/SQL Ref Cursor)
OCI_EXPORT boolean OCI_API OCI_ObjectSetShort(OCI_Object *obj, const otext *attr, short value)
Set an object attribute of type short.
bool IsTemporary() const
Check if the given lob is a temporary lob.
OCI_EXPORT boolean OCI_API OCI_DateAddMonths(OCI_Date *date, int nb)
Add or subtract months to a date handle.
ostring ToString() const override
Convert the interval value to a string using the default precisions of 10.
void Forget()
Cancel the prepared global transaction validation.
T Get(unsigned int index) const
Return the current value of the column at the given index in the resultset.
void ChangeTimeZone(const ostring &tzSrc, const ostring &tzDst)
Convert the date from one zone to another zone.
ostring GetAddress() const
Get the given AQ agent address.
OCI_EXPORT boolean OCI_API OCI_MutexAcquire(OCI_Mutex *mutex)
Acquire a mutex lock.
OCI_EXPORT boolean OCI_API OCI_ElemSetString(OCI_Elem *elem, const otext *value)
Set a string value to a collection element.
bool operator++(int)
Convenient operator overloading that performs a call to Next()
int GetMonth() const
Return the interval month value.
void SetDaySecond(int day, int hour, int min, int sec, int fsec)
Set the Day / Second parts.
Subscription Event.
Definition: ocilib.hpp:7093
OCI_EXPORT boolean OCI_API OCI_Ping(OCI_Connection *con)
Makes a round trip call to the server to confirm that the connection and the server are active...
big_uint GetChunkSize() const
Returns the current lob chunk size.
StatementType GetStatementType() const
Return the type of a SQL statement.
OCI_EXPORT unsigned int OCI_API OCI_GetAffectedRows(OCI_Statement *stmt)
Return the number of rows affected by the SQL statement.
Date LastDay() const
Return the last day of month from the current date object.
OCI_EXPORT unsigned int OCI_API OCI_LobRead(OCI_Lob *lob, void *buffer, unsigned int len)
[OBSOLETE] Read a portion of a lob into the given buffer
void Open()
Open a file for reading on the server.
void SetHours(int value)
Set the timestamp hours value.
static void Alter(const Connection &connection, const ostring &table, const ostring &comment, unsigned int primaryInstance=0, unsigned int secondaryInstance=0)
Alter the given queue table.
Reference Clone() const
Clone the current instance to a new one performing deep copy.
int GetDay() const
Return the interval day value.
Subscription()
Default constructor.
OCI_EXPORT unsigned short OCI_API OCI_GetUnsignedShort2(OCI_Resultset *rs, const otext *name)
Return the current unsigned short value of the column from its name in the resultset.
OCI_EXPORT boolean OCI_API OCI_ElemSetInterval(OCI_Elem *elem, OCI_Interval *value)
Assign an Interval handle to a collection element.
unsigned int GetRowCount() const
Return the number of rows successfully loaded into the database so far.
Subscription GetSubscription() const
Return the subscription that generated this event.
OCI_EXPORT unsigned int OCI_API OCI_PoolGetStatementCacheSize(OCI_Pool *pool)
Return the maximum number of statements to keep in the pool statement cache.
unsigned int GetSubType() const
Return the OCILIB object subtype of a column.
OCI_EXPORT boolean OCI_API OCI_BindDouble(OCI_Statement *stmt, const otext *name, double *data)
Bind a double variable.
OCI_EXPORT OCI_Ref *OCI_API OCI_ObjectGetRef(OCI_Object *obj, const otext *attr)
Return the Ref value of the given object attribute.
OCI_EXPORT boolean OCI_API OCI_ObjectSetDouble(OCI_Object *obj, const otext *attr, double value)
Set an object attribute of type double.
Date NextDay(const ostring &day) const
Return the date of next day of the week, after the current date object.
OCI_EXPORT OCI_Lob *OCI_API OCI_GetLob2(OCI_Resultset *rs, const otext *name)
Return the current lob value of the column from its name in the resultset.
Date(bool create=false)
Create an empty null Date object.
Enum< LobTypeValues > LobType
Type of Lob.
Definition: ocilib.hpp:425
OCI_EXPORT int OCI_API OCI_ColumnGetScale(OCI_Column *col)
Return the scale of the column for numeric columns.
static void Release(MutexHandle handle)
Release a mutex lock.
OCI_EXPORT boolean OCI_API OCI_SetDefaultLobPrefetchSize(OCI_Connection *con, unsigned int value)
Enable or disable prefetching for all LOBs fetched in the connection.
int GetMinutes() const
Return the date minutes value.
OCI_EXPORT boolean OCI_API OCI_CollDeleteElem(OCI_Coll *coll, unsigned int index)
Delete the element at the given position in the Nested Table Collection.
OCI_EXPORT boolean OCI_API OCI_TimestampFromText(OCI_Timestamp *tmsp, const otext *str, const otext *fmt)
Convert a string to a timestamp and store it in the given timestamp handle.
OCI_EXPORT int OCI_API OCI_DateCompare(OCI_Date *date, OCI_Date *date2)
Compares two date handles.
Enum< DataTypeValues > DataType
Column data type.
Definition: ocilib.hpp:298
OCI_Mutex * MutexHandle
Alias for an OCI_Mutex pointer.
Definition: ocilib.hpp:187
static void Drop(const Connection &connection, const ostring &queue)
Drop the given queue.
struct OCI_XID OCI_XID
Global transaction identifier.
void Copy(Lob &dest, big_uint offset, big_uint offsetDest, big_uint length) const
Copy the given portion of the lob content to another one.
ostring GetMessage() const
Retrieve the error message.
OCI_EXPORT boolean OCI_API OCI_MsgSetOriginalID(OCI_Msg *msg, const void *id, unsigned int len)
Set the original ID of the message in the last queue that generated this message. ...
Timestamp Clone() const
Clone the current instance to a new one performing deep copy.
OCI_EXPORT OCI_Interval *OCI_API OCI_GetInterval(OCI_Resultset *rs, unsigned int index)
Return the current interval value of the column at the given index in the resultset.
OCI_EXPORT boolean OCI_API OCI_ObjectSetRef(OCI_Object *obj, const otext *attr, OCI_Ref *value)
Set an object attribute of type Ref.
static ostring GetFormat(FormatType formatType)
Return the format string for implicit string conversions of the given type.
OCI_EXPORT OCI_Bind *OCI_API OCI_GetBind(OCI_Statement *stmt, unsigned int index)
Return the bind handle at the given index in the internal array of bind handle.
int GetHours() const
Return the interval hours value.
OCI_EXPORT OCI_Lob *OCI_API OCI_ObjectGetLob(OCI_Object *obj, const otext *attr)
Return the lob value of the given object attribute.
bool operator<=(const Date &other) const
Indicates if the current date value is inferior or equal to the given date value. ...
OCI_EXPORT boolean OCI_API OCI_NumberAdd(OCI_Number *number, unsigned int type, void *value)
Add the value of a native C numeric type to the given number.
unsigned int GetBindIndex(const ostring &name) const
Return the index of the bind from its name belonging to the statement.
OCI_EXPORT boolean OCI_API OCI_MsgGetOriginalID(OCI_Msg *msg, void *id, unsigned int *len)
Return the original ID of the message in the last queue that generated this message.
OCI_EXPORT boolean OCI_API OCI_ObjectSetNumber(OCI_Object *obj, const otext *attr, OCI_Number *value)
Set an object attribute of type number.
static void ShutdownDatabase(const ostring &db, const ostring &user, const ostring &pwd, Environment::ShutdownFlags shutdownFlags, Environment::ShutdownMode shutdownMode, Environment::SessionFlags sessionFlags=SessionSysDba)
Shutdown a database instance.
A connection or session with a specific database.
Definition: ocilib.hpp:1665
ostring GetFullSQLType() const
Return the Oracle SQL Full name including precision and size of the column data type.
OCI_EXPORT boolean OCI_API OCI_DirPathSetBufferSize(OCI_DirPath *dp, unsigned int size)
Set the size of the internal stream transfer buffer.
Lob()
Create an empty null Lob instance.
OCI_EXPORT boolean OCI_API OCI_Commit(OCI_Connection *con)
Commit current pending changes.
OCI_EXPORT boolean OCI_API OCI_NumberDivide(OCI_Number *number, unsigned int type, void *value)
Divide the given number with the value of a native C numeric.
OCI_EXPORT OCI_Ref *OCI_API OCI_GetRef(OCI_Resultset *rs, unsigned int index)
Return the current Ref value of the column at the given index in the resultset.
void Convert(const Timestamp &other)
Convert the current timestamp to the type of the given timestamp.
OCI_EXPORT boolean OCI_API OCI_StatementFree(OCI_Statement *stmt)
Free a statement and all resources associated to it (resultsets ...)
DequeueVisibility GetVisibility() const
Get the dequeuing/locking behavior.
OCI_EXPORT const otext *OCI_API OCI_GetString(OCI_Resultset *rs, unsigned int index)
Return the current string value of the column at the given index in the resultset.
unsigned int GetOpenedConnectionsCount() const
Return the current number of opened connections/sessions.
void Close()
Close the physical connection to the DB server.
OCI_EXPORT boolean OCI_API OCI_ElemSetBigInt(OCI_Elem *elem, big_int value)
Set a big int value to a collection element.
OCI_EXPORT unsigned int OCI_API OCI_ErrorGetType(OCI_Error *err)
Retrieve the type of error from error handle.
OCI_EXPORT int OCI_API OCI_DateCheck(OCI_Date *date)
Check if the given date is valid.
TypeInfo GetTypeInfo() const
Return the TypeInfo object describing the object.
Timestamp & operator+=(int value)
Increment the Timestamp by the given number of days.
int DaysBetween(const Date &other) const
Return the number of days with the given date.
void SetYear(int value)
Set the interval year value.
OCI_EXPORT boolean OCI_API OCI_BindBigInt(OCI_Statement *stmt, const otext *name, big_int *data)
Bind a big integer variable.
OCI_EXPORT unsigned int OCI_API OCI_DirPathLoad(OCI_DirPath *dp)
Loads the data converted to direct path stream format.
OCI_EXPORT OCI_Date *OCI_API OCI_GetDate(OCI_Resultset *rs, unsigned int index)
Return the current date value of the column at the given index in the resultset.
void SetExceptionQueue(const ostring &value)
Set the name of the queue to which the message is moved to if it cannot be processed successfully...
OCI_EXPORT boolean OCI_API OCI_Break(OCI_Connection *con)
Perform an immediate abort of any currently Oracle OCI call.
big_uint GetOffset() const
Returns the current R/W offset within the file.
NavigationMode GetNavigation() const
Return the navigation position of messages to retrieve from the queue.
T Read(unsigned int length)
Read a portion of a lob.
OCI_EXPORT boolean OCI_API OCI_SetTAFHandler(OCI_Connection *con, POCI_TAF_HANDLER handler)
Set the Transparent Application Failover (TAF) user handler.
OCI_EXPORT boolean OCI_API OCI_DirPathFree(OCI_DirPath *dp)
Free an OCI_DirPath handle.
static void Join(ThreadHandle handle)
Join the given thread.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfIntervals(OCI_Statement *stmt, const otext *name, OCI_Interval **data, unsigned int type, unsigned int nbelem)
Bind an array of interval handles.
OCI_EXPORT unsigned int OCI_API OCI_FileRead(OCI_File *file, void *buffer, unsigned int len)
Read a portion of a file into the given buffer.
void SetBindMode(BindMode value)
Set the binding mode of a SQL statement.
struct OCI_Interval OCI_Interval
Oracle internal interval representation.
Definition: ocilib.h:598
Object identifying the SQL data type LONG.
Definition: ocilib.hpp:5259
OCI_EXPORT boolean OCI_API OCI_DateFree(OCI_Date *date)
Free a date object.
OCI_EXPORT const otext *OCI_API OCI_MsgGetExceptionQueue(OCI_Msg *msg)
Get the Exception queue name of the message.
bool operator!=(const Timestamp &other) const
Indicates if the current Timestamp value is not equal the given Timestamp value.
static unsigned int GetCompileMinorVersion()
Return the minor version number of OCI used for compiling OCILIB.
bool operator>(const Interval &other) const
Indicates if the current Interval value is superior to the given Interval value.
struct OCI_Dequeue OCI_Dequeue
OCILIB encapsulation of A/Q dequeuing operations.
Definition: ocilib.h:769
int GetOracleErrorCode() const
Return the Oracle error code.
void Register(const Connection &connection, const ostring &name, ChangeTypes changeTypes, NotifyHandlerProc handler, unsigned int port=0, unsigned int timeout=0)
Register a notification against the given database.
Oracle Transaction object.
Definition: ocilib.hpp:2383
OCI_EXPORT OCI_Object *OCI_API OCI_GetObject2(OCI_Resultset *rs, const otext *name)
Return the current Object value of the column from its name in the resultset.
OCI_EXPORT boolean OCI_API OCI_GetAutoCommit(OCI_Connection *con)
Get current auto commit mode status.
OCI_EXPORT unsigned short OCI_API OCI_ElemGetUnsignedShort(OCI_Elem *elem)
Return the unsigned short value of the given collection element.
struct OCI_Statement OCI_Statement
Oracle SQL or PL/SQL statement.
Definition: ocilib.h:435
bool IsNullable() const
Return true if the column is nullable otherwise false.
Agent(const Connection &connection, const ostring &name=OTEXT(""), const ostring &address=OTEXT(""))
Create an AQ agent object.
OCI_EXPORT OCI_Ref *OCI_API OCI_GetRef2(OCI_Resultset *rs, const otext *name)
Return the current Ref value of the column from its name in the resultset.
OCI_EXPORT big_uint OCI_API OCI_FileGetSize(OCI_File *file)
Return the size in bytes of a file.
OCI_EXPORT OCI_File *OCI_API OCI_GetFile2(OCI_Resultset *rs, const otext *name)
Return the current File value of the column from its name in the resultset.
void SetMinutes(int value)
Set the interval minutes value.
int GetMinutes() const
Return the timestamp minutes value.
static unsigned int GetCompileMajorVersion()
Return the major version number of OCI used for compiling OCILIB.
Raw MakeRaw(void *result, unsigned int size)
Internal usage. Constructs a C++ Raw object from the given OCILIB raw buffer.
OCI_EXPORT boolean OCI_API OCI_BindInterval(OCI_Statement *stmt, const otext *name, OCI_Interval *data)
Bind an interval variable.
OCI_EXPORT boolean OCI_API OCI_FileSetName(OCI_File *file, const otext *dir, const otext *name)
Set the directory and file name of FILE handle.
OCI_EXPORT int OCI_API OCI_ErrorGetOCICode(OCI_Error *err)
Retrieve Oracle Error code from error handle.
OCI_EXPORT const otext *OCI_API OCI_MsgGetCorrelation(OCI_Msg *msg)
Get the correlation identifier of the message.
OCI_EXPORT int OCI_API OCI_DateAssign(OCI_Date *date, OCI_Date *date_src)
Assign the value of a date handle to another one.
void ExecutePrepared()
Execute a prepared SQL statement or PL/SQL block.
struct OCI_Bind OCI_Bind
Internal bind representation.
Definition: ocilib.h:447
ostring GetObjectName() const
Return the name of the object that generated the event.
OCI_EXPORT boolean OCI_API OCI_BindInt(OCI_Statement *stmt, const otext *name, int *data)
Bind an integer variable.
OCI_EXPORT boolean OCI_API OCI_ThreadKeyCreate(const otext *name, POCI_THREADKEYDEST destfunc)
Create a thread key object.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfTimestamps(OCI_Statement *stmt, const otext *name, OCI_Timestamp **data, unsigned int type, unsigned int nbelem)
Bind an array of timestamp handles.
OCI_EXPORT boolean OCI_API OCI_ObjectSetObject(OCI_Object *obj, const otext *attr, OCI_Object *value)
Set an object attribute of type Object.
int GetHours() const
Return the date hours value.
OCI_EXPORT boolean OCI_API OCI_NumberToText(OCI_Number *number, const otext *fmt, int size, otext *str)
Convert a number value from the given number handle to a string.
OCI_EXPORT boolean OCI_API OCI_TimestampGetDateTime(OCI_Timestamp *tmsp, int *year, int *month, int *day, int *hour, int *min, int *sec, int *fsec)
Extract the date and time parts from a date handle.
struct OCI_Subscription OCI_Subscription
OCILIB encapsulation of Oracle DCN notification.
Definition: ocilib.h:729
static Environment::EnvironmentFlags GetMode()
Return the Environment mode flags.
void Close()
Close explicitly a Lob.
int GetDay() const
Return the date day value.
TimestampTypeValues
Interval types enumerated values.
Definition: ocilib.hpp:3530
void Parse(const ostring &sql)
Parse a SQL statement or PL/SQL block.
OCI_EXPORT boolean OCI_API OCI_BindFile(OCI_Statement *stmt, const otext *name, OCI_File *data)
Bind a File variable.
ostring ToString() const override
return a string representation of the current collection
StartFlagsValues
Oracle instance start flags enumerated values.
Definition: ocilib.hpp:801
bool Last()
Fetch the last row of the resultset.
bool operator<(const Timestamp &other) const
Indicates if the current Timestamp value is inferior to the given Timestamp value.
AQ identified agent for messages delivery.
Definition: ocilib.hpp:7220
OCI_EXPORT boolean OCI_API OCI_BindArrayOfShorts(OCI_Statement *stmt, const otext *name, short *data, unsigned int nbelem)
Bind an array of shorts.
Enum< OracleVersionValues > OracleVersion
Oracle Version.
Definition: ocilib.hpp:252
TypeInfo GetTypeInfo() const
Return the type information object associated to the column.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfDoubles(OCI_Statement *stmt, const otext *name, double *data, unsigned int nbelem)
Bind an array of doubles.
virtual ~Exception()
Virtual destructor required for deriving from std::exception.
void SetEntry(unsigned int rowIndex, unsigned int colIndex, const T &value, bool complete=true)
Set the value of the given row/column array entry from the given string.
void SetSeconds(int value)
Set the date seconds value.
Column GetColumn(unsigned int index) const
Return the column from its index in the resultset.
OCI_EXPORT OCI_Statement *OCI_API OCI_ResultsetGetStatement(OCI_Resultset *rs)
Return the statement handle associated with a resultset handle.
OCI_EXPORT short OCI_API OCI_ObjectGetShort(OCI_Object *obj, const otext *attr)
Return the short value of the given object attribute.
OCI_EXPORT boolean OCI_API OCI_ObjectSetColl(OCI_Object *obj, const otext *attr, OCI_Coll *value)
Set an object attribute of type Collection.
OCI_EXPORT int OCI_API OCI_TimestampCompare(OCI_Timestamp *tmsp, OCI_Timestamp *tmsp2)
Compares two timestamp handles.
OCI_EXPORT double OCI_API OCI_GetDouble2(OCI_Resultset *rs, const otext *name)
Return the current double value of the column from its name in the resultset.
ObjectEvent GetObjectEvent() const
Return the type of operation reported by a notification.
Simplified resolver for scalar types that do not need translation.
Definition: ocilib_impl.hpp:80
OCI_EXPORT boolean OCI_API OCI_ElemSetBoolean(OCI_Elem *elem, boolean value)
Set a boolean value to a collection element.
OCI_EXPORT boolean OCI_API OCI_BindObject(OCI_Statement *stmt, const otext *name, OCI_Object *data)
Bind an object (named type) variable.
Transaction GetTransaction() const
Return the current transaction of the connection.
OCI_EXPORT const otext *OCI_API OCI_SubscriptionGetName(OCI_Subscription *sub)
Return the name of the given registered subscription.
static Environment::ImportMode GetImportMode()
Return the Oracle shared library import mode.
OCI_EXPORT unsigned int OCI_API OCI_PoolGetOpenedCount(OCI_Pool *pool)
Return the current number of opened connections/sessions.
OCI_EXPORT OCI_Connection *OCI_API OCI_TypeInfoGetConnection(OCI_TypeInfo *typinf)
Retrieve connection handle from the type info handle.
OCI_EXPORT unsigned int OCI_API OCI_ColumnGetSubType(OCI_Column *col)
Return the OCILIB object subtype of a column.
OCI_EXPORT unsigned int OCI_API OCI_BindGetDataSize(OCI_Bind *bnd)
Return the actual size of the element held by the given bind handle.
void Reset()
Reset internal arrays and streams to prepare another load.
int GetYear() const
Return the interval year value.
OCI_EXPORT boolean OCI_API OCI_FileIsOpen(OCI_File *file)
Check if the specified file is opened within the file handle.
OCI_EXPORT int OCI_API OCI_GetInt2(OCI_Resultset *rs, const otext *name)
Return the current integer value of the column from its name in the resultset.
ostring GetDatabase() const
Return the Oracle server database name of the connected database/service name.
OCI_EXPORT boolean OCI_API OCI_PoolSetNoWait(OCI_Pool *pool, boolean value)
Set the waiting mode used when no more connections/sessions are available from the pool...
OCI_EXPORT boolean OCI_API OCI_DateGetDateTime(OCI_Date *date, int *year, int *month, int *day, int *hour, int *min, int *sec)
Extract the date and time parts from a date handle.
OCI_EXPORT OCI_Long *OCI_API OCI_GetLong(OCI_Resultset *rs, unsigned int index)
Return the current Long value of the column at the given index in the resultset.
OCI_EXPORT const otext *OCI_API OCI_EventGetObject(OCI_Event *event)
Return the name of the object that generated the event.
bool operator>=(const Timestamp &other) const
Indicates if the current Timestamp value is superior or equal to the given Timestamp value...
OCI_EXPORT big_uint OCI_API OCI_ObjectGetUnsignedBigInt(OCI_Object *obj, const otext *attr)
Return the unsigned big integer value of the given object attribute.
OCI_EXPORT big_uint OCI_API OCI_GetUnsignedBigInt2(OCI_Resultset *rs, const otext *name)
Return the current unsigned big integer value of the column from its name in the resultset.
OCI_EXPORT OCI_Timestamp *OCI_API OCI_GetInstanceStartTime(OCI_Connection *con)
Return the date and time (Timestamp) server instance start of the connected database/service name...
OCI_EXPORT OCI_Date *OCI_API OCI_GetDate2(OCI_Resultset *rs, const otext *name)
Return the current date value of the column from its name in the resultset.
OCI_EXPORT unsigned int OCI_API OCI_PoolGetIncrement(OCI_Pool *pool)
Return the increment for connections/sessions to be opened to the database when the pool is not full...
static void Stop(const Connection &connection, const ostring &queue, bool stopEnqueue=true, bool stopDequeue=true, bool wait=true)
Stop enqueuing or dequeuing or both on the given queue.
OCI_EXPORT boolean OCI_API OCI_DequeueSetConsumer(OCI_Dequeue *dequeue, const otext *consumer)
Set the current consumer name to retrieve message for.
OCI_EXPORT const otext *OCI_API OCI_GetSessionTag(OCI_Connection *con)
Return the tag associated the given connection.
OCI_EXPORT unsigned int OCI_API OCI_ElemGetRawSize(OCI_Elem *elem)
Return the raw attribute value size of the given element handle.
bool operator==(const Lob &other) const
Indicates if the current lob value is equal to the given lob value.
int GetMonth() const
Return the date month value.
Reference GetReference() const
Creates a reference on the current object.
OCI_EXPORT boolean OCI_API OCI_QueueTableAlter(OCI_Connection *con, const otext *queue_table, const otext *comment, unsigned int primary_instance, unsigned int secondary_instance)
Alter the given queue table.
OCI_EXPORT const otext *OCI_API OCI_TypeInfoGetName(OCI_TypeInfo *typinf)
Return the name described by the type info object.
ostring GetTrace(SessionTrace trace) const
Get the current trace for the trace type from the given connection.
OCI_EXPORT boolean OCI_API OCI_MsgReset(OCI_Msg *msg)
Reset all attributes of a message object.
void SetStatementCacheSize(unsigned int value)
Set the maximum number of statements to keep in the pool&#39;s statement cache.
struct OCI_Timestamp OCI_Timestamp
Oracle internal timestamp representation.
Definition: ocilib.h:588
int GetPriority() const
Return the priority of the message.
OCI_EXPORT boolean OCI_API OCI_AgentSetName(OCI_Agent *agent, const otext *name)
Set the given AQ agent name.
OCI_EXPORT boolean OCI_API OCI_QueueTablePurge(OCI_Connection *con, const otext *queue_table, const otext *purge_condition, boolean block, unsigned int delivery_mode)
Purge messages from the given queue table.
void SetBufferSize(unsigned int value)
Set the size of the internal stream transfer buffer.
OCI_EXPORT unsigned int OCI_API OCI_PoolGetMax(OCI_Pool *pool)
Return the maximum number of connections/sessions that can be opened to the database.
OCI_EXPORT boolean OCI_API OCI_LobIsEqual(OCI_Lob *lob, OCI_Lob *lob2)
Compare two lob handles for equality.
ostring ToString() const override
return a string representation of the current reference
ostring GetFormat(FormatType formatType)
Return the format string for implicit string conversions of the given type.
ostring GetSql() const
Return the last SQL or PL/SQL statement prepared or executed by the statement.
OCI_EXPORT boolean OCI_API OCI_LobAssign(OCI_Lob *lob, OCI_Lob *lob_src)
Assign a lob to another one.
OCI_EXPORT big_uint OCI_API OCI_LobErase(OCI_Lob *lob, big_uint offset, big_uint len)
Erase a portion of the lob at a given position.
OCI_EXPORT const otext *OCI_API OCI_GetString2(OCI_Resultset *rs, const otext *name)
Return the current string value of the column from its name in the resultset.
OCI_EXPORT OCI_TypeInfo *OCI_API OCI_CollGetTypeInfo(OCI_Coll *coll)
Return the type info object associated to the collection.
Template Enumeration template class providing some type safety to some extends for manipulating enume...
OCI_EXPORT unsigned int OCI_API OCI_LobGetChunkSize(OCI_Lob *lob)
Returns the chunk size of a LOB.
void Flush()
Flush the lob content to the server (if applicable)
OCI_EXPORT boolean OCI_API OCI_RefToText(OCI_Ref *ref, unsigned int size, otext *str)
Converts a Ref handle value to a hexadecimal string.
OCI_EXPORT boolean OCI_API OCI_ThreadJoin(OCI_Thread *thread)
Join the given thread.
OCI_EXPORT unsigned int OCI_API OCI_GetCharset(void)
Return the OCILIB charset type.
Timestamp & operator++()
Increment the timestamp by 1 day.
OCI_EXPORT float OCI_API OCI_ElemGetFloat(OCI_Elem *elem)
Return the float value of the given collection element.
OCI_EXPORT unsigned int OCI_API OCI_GetServerRevisionVersion(OCI_Connection *con)
Return the revision version number of the connected database server.
Timestamp operator-(int value) const
Return a new Timestamp holding the current Timestamp value decremented by the given number of days...
OCI_EXPORT boolean OCI_API OCI_ObjectAssign(OCI_Object *obj, OCI_Object *obj_src)
Assign an object to another one.
void SetDateTime(int year, int month, int day, int hour, int min, int sec)
Set the date and time part.
Long()
Create an empty null Long instance.
void Reset()
Reset all attributes of the message.
OCI_EXPORT OCI_TypeInfo *OCI_API OCI_TypeInfoGet(OCI_Connection *con, const otext *name, unsigned int type)
Retrieve the available type info information.
unsigned int GetServerMinorVersion() const
Return the minor version number of the connected database server.
Statement GetStatement() const
Return the statement associated with the resultset.
OCI_EXPORT boolean OCI_API OCI_BindRaw(OCI_Statement *stmt, const otext *name, void *data, unsigned int len)
Bind a raw buffer.
static T Check(T result)
Internal usage. Checks if the last OCILIB function call has raised an error. If so, it raises a C++ exception using the retrieved error handle.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfLobs(OCI_Statement *stmt, const otext *name, OCI_Lob **data, unsigned int type, unsigned int nbelem)
Bind an array of Lob handles.
void SetHours(int value)
Set the date hours value.
static void Create(const Connection &connection, const ostring &table, const ostring &payloadType, bool multipleConsumers, const ostring &storageClause=OTEXT(""), const ostring &sortList=OTEXT(""), GroupingMode groupingMode=None, const ostring &comment=OTEXT(""), unsigned int primaryInstance=0, unsigned int secondaryInstance=0, const ostring &compatible=OTEXT(""))
Create a queue table for messages of the given type.
void FromString(const ostring &data)
Assign to the interval object the value provided by the input interval string.
Connection GetConnection() const
Return the connection associated with a statement.
Number Clone() const
Clone the current instance to a new one performing deep copy.
OCI_EXPORT boolean OCI_API OCI_ElemGetBoolean(OCI_Elem *elem)
Return the boolean value of the given collection element.
OCI_EXPORT boolean OCI_API OCI_DirPathSetCacheSize(OCI_DirPath *dp, unsigned int size)
Set number of elements in the date cache.
OCI_EXPORT OCI_Date *OCI_API OCI_ElemGetDate(OCI_Elem *elem)
Return the Date value of the given collection element.
static void ChangeUserPassword(const ostring &db, const ostring &user, const ostring &pwd, const ostring &newPwd)
Change the password of the given user on the given database.
OCI_EXPORT unsigned int OCI_API OCI_GetRowCount(OCI_Resultset *rs)
Retrieve the number of rows fetched so far.
OCI_EXPORT unsigned int OCI_API OCI_LobWrite(OCI_Lob *lob, void *buffer, unsigned int len)
[OBSOLETE] Write a buffer into a LOB
OCI_EXPORT boolean OCI_API OCI_BindSetDataSizeAtPos(OCI_Bind *bnd, unsigned int position, unsigned int size)
Set the size of the element at the given position in the bind input array.
OCI_EXPORT unsigned int OCI_API OCI_BindArrayGetSize(OCI_Statement *stmt)
Return the current input array size for bulk operations.
OCI_EXPORT unsigned int OCI_API OCI_EventGetType(OCI_Event *event)
Return the type of event reported by a notification.
boolean OCI_API OCI_BindSetCharsetForm(OCI_Bind *bnd, unsigned int csfrm)
Set the charset form of the given character based bind variable.
OCI_EXPORT boolean OCI_API OCI_DatabaseShutdown(const otext *db, const otext *user, const otext *pwd, unsigned int sess_mode, unsigned int shut_mode, unsigned int shut_flag)
Shutdown a database instance.
OCI_EXPORT boolean OCI_API OCI_DateGetTime(OCI_Date *date, int *hour, int *min, int *sec)
Extract the time part from a date handle.
OCI_EXPORT const otext *OCI_API OCI_GetPassword(OCI_Connection *con)
Return the current logged user password.
ShutdownModeValues
Oracle instance shutdown modes enumerated values.
Definition: ocilib.hpp:825
bool operator<=(const Interval &other) const
Indicates if the current Interval value is inferior or equal to the given Interval value...
OCI_EXPORT boolean OCI_API OCI_TimestampGetTime(OCI_Timestamp *tmsp, int *hour, int *min, int *sec, int *fsec)
Extract the time portion from a timestamp handle.
void SetLongMaxSize(unsigned int value)
Set the LONG data type piece buffer size.
OCI_EXPORT boolean OCI_API OCI_NumberFree(OCI_Number *number)
Free a number object.
unsigned int GetColumnIndex(const ostring &name) const
Return the index of the column in the result from its name.
Column GetColumn(unsigned int index) const
Return the column from its index in the resultset.
void Close()
Destroy the current Oracle pool of connections or sessions.
OCI_EXPORT unsigned int OCI_API OCI_GetUnsignedInt2(OCI_Resultset *rs, const otext *name)
Return the current unsigned integer value of the column from its name in the resultset.
OCI_EXPORT OCI_Timestamp *OCI_API OCI_ObjectGetTimestamp(OCI_Object *obj, const otext *attr)
Return the timestamp value of the given object attribute.
OCI_EXPORT boolean OCI_API OCI_BindSetDirection(OCI_Bind *bnd, unsigned int direction)
Set the direction mode of a bind handle.
OCI_EXPORT boolean OCI_API OCI_EnqueueGetRelativeMsgID(OCI_Enqueue *enqueue, void *id, unsigned int *len)
Get the current associated message identifier used for enqueuing messages using a sequence deviation...
struct OCI_Msg OCI_Msg
OCILIB encapsulation of A/Q message.
Definition: ocilib.h:749
OCI_EXPORT boolean OCI_API OCI_IsRebindingAllowed(OCI_Statement *stmt)
Indicate if rebinding is allowed on the given statement.
OCI_EXPORT boolean OCI_API OCI_TimestampGetTimeZoneName(OCI_Timestamp *tmsp, int size, otext *str)
Return the time zone name of a timestamp handle.
OCI_EXPORT unsigned int OCI_API OCI_TransactionGetMode(OCI_Transaction *trans)
Return global transaction mode.
OCI_EXPORT OCI_Statement *OCI_API OCI_BindGetStatement(OCI_Bind *bnd)
Return the statement handle associated with a bind handle.
OCI_EXPORT boolean OCI_API OCI_IntervalGetDaySecond(OCI_Interval *itv, int *day, int *hour, int *min, int *sec, int *fsec)
Return the day / time portion of an interval handle.
EventType GetType() const
Return the type of event reported by a notification.
OCI_EXPORT boolean OCI_API OCI_ElemSetRef(OCI_Elem *elem, OCI_Ref *value)
Assign a Ref handle to a collection element.
const void * ThreadId
Thread Unique ID.
Definition: ocilib.hpp:205
OCI_EXPORT OCI_Object *OCI_API OCI_ObjectGetObject(OCI_Object *obj, const otext *attr)
Return the object value of the given object attribute.
OCI_EXPORT unsigned int OCI_API OCI_EventGetOperation(OCI_Event *event)
Return the type of operation reported by a notification.
unsigned int GetMaxRows() const
Return the maximum number of rows allocated in the OCI and OCILIB internal arrays of rows...
void SetConsumer(const ostring &value)
Set the current consumer name to retrieve message for.
void SetUserData(AnyPointer value)
Associate a pointer to user data to the given connection.
OCI_EXPORT boolean OCI_API OCI_ThreadKeySetValue(const otext *name, void *value)
Set a thread key value.
OCI_EXPORT short OCI_API OCI_GetShort2(OCI_Resultset *rs, const otext *name)
Return the current short value of the column from its name in the resultset.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfUnsignedBigInts(OCI_Statement *stmt, const otext *name, big_uint *data, unsigned int nbelem)
Bind an array of unsigned big integers.
OCI_EXPORT boolean OCI_API OCI_TimestampIntervalSub(OCI_Timestamp *tmsp, OCI_Interval *itv)
Subtract an interval value from a timestamp value of a timestamp handle.
void SetDay(int value)
Set the date day value.
OCI_EXPORT boolean OCI_API OCI_MutexFree(OCI_Mutex *mutex)
Destroy a mutex object.
bool operator--(int)
Convenient operator overloading that performs a call to Prev()
void FromString(const ostring &data, const ostring &format=OCI_STRING_FORMAT_DATE)
Assign to the timestamp object the value provided by the input date time string.
ostring GetConsumer() const
Get the current consumer name associated with the dequeuing process.
T GetContent() const
Return the string read from a fetch sequence.
static Date SysDate()
Return the current system date time.
ostring GetExceptionQueue() const
Get the Exception queue name of the message.
OCI_EXPORT boolean OCI_API OCI_TimestampFree(OCI_Timestamp *tmsp)
Free an OCI_Timestamp handle.
OCI_EXPORT unsigned int OCI_API OCI_BindGetSubtype(OCI_Bind *bnd)
Return the OCILIB object subtype of the given bind.
OCI_EXPORT boolean OCI_API OCI_SetUserData(OCI_Connection *con, void *data)
Associate a pointer to user data to the given connection.
unsigned int Write(const T &content)
Write the given content at the current position within the lob.
OCI_EXPORT OCI_Date *OCI_API OCI_DateCreate(OCI_Connection *con)
Create a local date object.
CharsetForm GetCharsetForm() const
Return the charset form of the given column.
OCI_EXPORT OCI_Ref *OCI_API OCI_RefCreate(OCI_Connection *con, OCI_TypeInfo *typinf)
Create a local Ref instance.
OCI_EXPORT OCI_Interval *OCI_API OCI_IntervalCreate(OCI_Connection *con, unsigned int type)
Create a local interval object.
OCI_EXPORT OCI_Connection *OCI_API OCI_LobGetConnection(OCI_Lob *lob)
Retrieve connection handle from the lob handle.
OCI_EXPORT boolean OCI_API OCI_EnqueueSetSequenceDeviation(OCI_Enqueue *enqueue, unsigned int sequence)
Set the enqueuing sequence of messages to put in the queue.
OCI_EXPORT const otext *OCI_API OCI_GetDBName(OCI_Connection *con)
Return the Oracle server database name of the connected database/service name.
void SetDateTime(int year, int month, int day, int hour, int min, int sec, int fsec, const ostring &timeZone=OTEXT(""))
Set the timestamp value from given date time parts.
OCI_EXPORT boolean OCI_API OCI_ElemIsNull(OCI_Elem *elem)
Check if the collection element value is null.
void Stop()
Stop current global transaction.
void SetConversionMode(ConversionMode value)
Set the direct path conversion mode.
Static class in charge of library initialization / cleanup.
Definition: ocilib.hpp:610
OCI_EXPORT boolean OCI_API OCI_RegisterBigInt(OCI_Statement *stmt, const otext *name)
Register a big integer output bind placeholder.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfFloats(OCI_Statement *stmt, const otext *name, float *data, unsigned int nbelem)
Bind an array of floats.
OCI_EXPORT big_uint OCI_API OCI_FileGetOffset(OCI_File *file)
Return the current position in the file.
void SetPrefetchMemory(unsigned int value)
Set the amount of memory pre-fetched by OCI Client.
OCI_EXPORT boolean OCI_API OCI_SetLongMaxSize(OCI_Statement *stmt, unsigned int size)
Set the LONG data type piece buffer size.
OCI_EXPORT OCI_TypeInfo *OCI_API OCI_RefGetTypeInfo(OCI_Ref *ref)
Return the type info object associated to the Ref.
OCI_EXPORT boolean OCI_API OCI_ElemSetLob(OCI_Elem *elem, OCI_Lob *value)
Assign a Lob handle to a collection element.
OCI_EXPORT OCI_File *OCI_API OCI_FileCreate(OCI_Connection *con, unsigned int type)
Create a file object instance.
PropertyFlags GetPropertyFlags() const
Return the column property flags.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfUnsignedInts(OCI_Statement *stmt, const otext *name, unsigned int *data, unsigned int nbelem)
Bind an array of unsigned integers.
void SetMinutes(int value)
Set the timestamp minutes value.
OCI_EXPORT OCI_Transaction *OCI_API OCI_TransactionCreate(OCI_Connection *con, unsigned int timeout, unsigned int mode, OCI_XID *pxid)
Create a new global transaction or a serializable/read-only local transaction.
void SetCorrelation(const ostring &value)
set the correlation identifier of the message to be dequeued
Message Get()
Dequeue messages from the given queue.
void SetDate(int year, int month, int day)
Set the date part.
Reference()
Create an empty null Reference instance.
Class used for handling transient collection value. it is used internally by the Collection<T> class:...
Definition: ocilib.hpp:4899
OCI_EXPORT OCI_Coll *OCI_API OCI_GetColl(OCI_Resultset *rs, unsigned int index)
Return the current Collection value of the column at the given index in the resultset.
int GetLeadingPrecision() const
Return the leading precision of the column for Interval columns.
AllocatedBytesValues
Allocated Bytes enumerated values.
Definition: ocilib.hpp:888
void Append(const T &data)
Append the given element value at the end of the collection.
OCI_EXPORT unsigned int OCI_API OCI_ObjectGetUnsignedInt(OCI_Object *obj, const otext *attr)
Return the unsigned integer value of the given object attribute.
static void Create(const Connection &connection, const ostring &queue, const ostring &table, QueueType type=NormalQueue, unsigned int maxRetries=0, unsigned int retryDelay=0, unsigned int retentionTime=0, bool dependencyTracking=false, const ostring &comment=OTEXT(""))
Create a queue.
OCI_EXPORT boolean OCI_API OCI_ElemSetUnsignedShort(OCI_Elem *elem, unsigned short value)
Set a unsigned short value to a collection element.
static void Migrate(const Connection &connection, const ostring &table, const ostring &compatible=OTEXT(""))
Migrate a queue table from one version to another.
bool operator>=(const Interval &other) const
Indicates if the current Interval value is superior or equal to the given Interval value...
unsigned int GetCurrentRows() const
Return the current number of rows used in the OCILIB internal arrays of rows.
OCI_EXPORT boolean OCI_API OCI_SetPassword(OCI_Connection *con, const otext *password)
Change the password of the logged user.
struct OCI_Ref OCI_Ref
Oracle REF type representation.
Definition: ocilib.h:655
unsigned int GetErrorColumn()
Return the index of a column which caused an error during data conversion.
void GetDate(int &year, int &month, int &day) const
Extract the date parts.
void SetRelativeMsgID(const Raw &value)
Set the message identifier of the message to be dequeued.
ChangeTypesValues
Subscription changes flags values.
Definition: ocilib.hpp:6979
void SetAgents(std::vector< Agent > &agents)
Set the Agent list to listen to message for.
OCI_EXPORT int OCI_API OCI_TimestampCheck(OCI_Timestamp *tmsp)
Check if the given timestamp is valid.
void(* NotifyHandlerProc)(Event &evt)
User callback for subscriptions event notifications.
Definition: ocilib.hpp:6972
void SetTransaction(const Transaction &transaction)
Set a transaction to a connection.
OCI_EXPORT big_uint OCI_API OCI_GetUnsignedBigInt(OCI_Resultset *rs, unsigned int index)
Return the current unsigned big integer value of the column at the given index in the resultset...
int GetPrecision() const
Return the precision of the column for numeric columns.
OCI_EXPORT boolean OCI_API OCI_TransactionForget(OCI_Transaction *trans)
Cancel the prepared global transaction validation.
OCI_EXPORT unsigned int OCI_API OCI_GetRaw2(OCI_Resultset *rs, const otext *name, void *buffer, unsigned int len)
Copy the current raw value of the column from its name into the specified buffer. ...
unsigned int GetLength() const
Return the buffer length.
OCI_EXPORT boolean OCI_API OCI_IntervalToText(OCI_Interval *itv, int leading_prec, int fraction_prec, int size, otext *str)
Convert an interval value from the given interval handle to a string.
void SetCorrelation(const ostring &value)
Set the correlation identifier of the message.
OCI_EXPORT boolean OCI_API OCI_EnableWarnings(boolean value)
Enable or disable Oracle warning notifications.
OCI_EXPORT boolean OCI_API OCI_RegisterInt(OCI_Statement *stmt, const otext *name)
Register an integer output bind placeholder.
OCI_EXPORT OCI_Resultset *OCI_API OCI_GetResultset(OCI_Statement *stmt)
Retrieve the resultset handle from an executed statement.
unsigned int ForEach(T callback)
Fetch all rows in the resultset and call the given callback for row.
CollectionType GetType() const
Return the type of the collection.
void * AnyPointer
Alias for the generic void pointer.
Definition: ocilib.hpp:169
OCI_EXPORT unsigned int OCI_API OCI_GetBindIndex(OCI_Statement *stmt, const otext *name)
Return the index of the bind from its name belonging to the given statement.
OCI_EXPORT boolean OCI_API OCI_TransactionFree(OCI_Transaction *trans)
Free current transaction.
const char * what() const override
Override the std::exception::what() method.
ExceptionType GetType() const
Return the Exception type.
OCI_EXPORT boolean OCI_API OCI_ObjectSetUnsignedBigInt(OCI_Object *obj, const otext *attr, big_uint value)
Set an object attribute of type unsigned big int.
unsigned int GetAffectedRows() const
return the number of rows successfully processed during in the last conversion or loading call ...
OCI_EXPORT void *OCI_API OCI_GetUserData(OCI_Connection *con)
Return the pointer to user data previously associated with the connection.
Raw GetRelativeMsgID() const
Get the current associated message identifier used for enqueuing messages using a sequence deviation...
void Subscribe(unsigned int port, unsigned int timeout, NotifyAQHandlerProc handler)
Subscribe for asynchronous messages notifications.
Connection GetConnection() const
Return the connection within the error occurred.
static void Cleanup()
Clean up all resources allocated by the environment.
void SetMilliSeconds(int value)
Set the interval milliseconds value.
OCI_EXPORT unsigned int OCI_API OCI_DequeueGetMode(OCI_Dequeue *dequeue)
Get the dequeuing/locking behavior.
OCI_EXPORT unsigned short OCI_API OCI_GetUnsignedShort(OCI_Resultset *rs, unsigned int index)
Return the current unsigned short value of the column at the given index in the resultset.
OCI_EXPORT boolean OCI_API OCI_FetchFirst(OCI_Resultset *rs)
Fetch the first row of the resultset.
void Clear()
Clear all items of the collection.
bool IsServerAlive() const
Indicate if the connection is still connected to the server.
Interval operator+(const Interval &other) const
Return a new Interval holding the sum of the current Interval value and the given Interval value...
OCI_EXPORT boolean OCI_API OCI_DateSetTime(OCI_Date *date, int hour, int min, int sec)
Set the time portion if the given date handle.
OCI_EXPORT OCI_Timestamp *OCI_API OCI_GetTimestamp2(OCI_Resultset *rs, const otext *name)
Return the current timestamp value of the column from its name in the resultset.
void SetBindArraySize(unsigned int size)
Set the input array size for bulk operations.
Interval & operator+=(const Interval &other)
Increment the current Value with the given Interval value.
static void Run(ThreadHandle handle, ThreadProc func, void *args)
Execute the given routine within the given thread.
OCI_EXPORT unsigned int OCI_API OCI_SubscriptionGetPort(OCI_Subscription *sub)
Return the port used by the notification.
OCI_EXPORT unsigned int OCI_API OCI_RefGetHexSize(OCI_Ref *ref)
Returns the size of the hex representation of the given Ref handle.
unsigned int GetSize() const
Returns the total number of elements in the collection.
OCI_EXPORT const otext *OCI_API OCI_AgentGetAddress(OCI_Agent *agent)
Get the given AQ agent address.
unsigned int GetFetchSize() const
Return the number of rows fetched per internal server fetch call.
OCI_EXPORT unsigned int OCI_API OCI_GetOCICompileVersion(void)
Return the version of OCI used for compilation.
OCI_EXPORT boolean OCI_API OCI_NumberSub(OCI_Number *number, unsigned int type, void *value)
Subtract the value of a native C numeric type to the given number.
OCI_EXPORT boolean OCI_API OCI_DatabaseStartup(const otext *db, const otext *user, const otext *pwd, unsigned int sess_mode, unsigned int start_mode, unsigned int start_flag, const otext *spfile)
Start a database instance.
OCI_EXPORT float OCI_API OCI_ObjectGetFloat(OCI_Object *obj, const otext *attr)
Return the float value of the given object attribute.
void Prepare()
Prepare a global transaction validation.
OCI_EXPORT int OCI_API OCI_ColumnGetLeadingPrecision(OCI_Column *col)
Return the leading precision of the column for interval columns.
void SetMode(EnqueueMode value)
Set the enqueuing mode of messages to put in the queue.
OCI_EXPORT unsigned int OCI_API OCI_GetServerMinorVersion(OCI_Connection *con)
Return the minor version number of the connected database server.
OCI_EXPORT boolean OCI_API OCI_DirPathReset(OCI_DirPath *dp)
Reset internal arrays and streams to prepare another load.
OCI_EXPORT OCI_Interval *OCI_API OCI_ElemGetInterval(OCI_Elem *elem)
Return the Interval value of the given collection element.
OCI_EXPORT boolean OCI_API OCI_MsgSetObject(OCI_Msg *msg, OCI_Object *obj)
Set the object payload of the given message.
OCI_EXPORT unsigned int OCI_API OCI_CollGetMax(OCI_Coll *coll)
Returns the maximum number of elements of the given collection.
OCI_EXPORT const otext *OCI_API OCI_DequeueGetCorrelation(OCI_Dequeue *dequeue)
Get the correlation identifier of the message to be dequeued.
OCI_EXPORT int OCI_API OCI_NumberCompare(OCI_Number *number1, OCI_Number *number2)
Compares two number handles.
Object identifying the SQL data types VARRAY and NESTED TABLE.
Definition: ocilib.hpp:4990
void SetPriority(int value)
Set the priority of the message.
OCI_EXPORT unsigned int OCI_API OCI_ElemGetRaw(OCI_Elem *elem, void *value, unsigned int len)
Read the RAW value of the collection element into the given buffer.
ostring ToString() const override
Convert the date value to a string using default format OCI_STRING_FORMAT_DATE.
bool IsAttributeNull(const ostring &name) const
Check if an object attribute is null.
Timestamp & operator--()
Decrement the Timestamp by 1 day.
OCI_EXPORT OCI_Statement *OCI_API OCI_GetStatement2(OCI_Resultset *rs, const otext *name)
Return the current cursor value of the column from its name in the resultset.
int GetScale() const
Return the scale of the column for numeric columns.
OCI_EXPORT boolean OCI_API OCI_FileFree(OCI_File *file)
Free a local File object.
OCI_EXPORT unsigned int OCI_API OCI_ColumnGetPropertyFlags(OCI_Column *col)
Return the column property flags.
void SetNoWait(bool value)
Set the waiting mode used when no more connections/sessions are available from the pool...
OCI_EXPORT boolean OCI_API OCI_LobOpen(OCI_Lob *lob, unsigned int mode)
Open explicitly a Lob.
void SetMonth(int value)
Set the date month value.
struct OCI_Date OCI_Date
Oracle internal date representation.
Definition: ocilib.h:578
OCI_EXPORT big_int OCI_API OCI_GetBigInt(OCI_Resultset *rs, unsigned int index)
Return the current big integer value of the column at the given index in the resultset.
Lob Clone() const
Clone the current instance to a new one performing deep copy.
bool operator<=(const Timestamp &other) const
Indicates if the current Timestamp value is inferior or equal to the given Timestamp value...
unsigned int GetMaxSize() const
Return the maximum number of connections/sessions that can be opened to the database.
OracleVersion GetVersion() const
Return the Oracle version supported by the connection.
unsigned int GetStatementCacheSize() const
Return the maximum number of statements to keep in the pool&#39;s statement cache.
OCI_EXPORT unsigned int OCI_API OCI_DequeueGetNavigation(OCI_Dequeue *dequeue)
Return the navigation position of messages to retrieve from the queue.
OCI_EXPORT OCI_Number *OCI_API OCI_ElemGetNumber(OCI_Elem *elem)
Return the number value of the given collection element.
OCI_EXPORT boolean OCI_API OCI_PoolGetNoWait(OCI_Pool *pool)
Get the waiting mode used when no more connections/sessions are available from the pool...
OCI_EXPORT unsigned int OCI_API OCI_DirPathConvert(OCI_DirPath *dp)
Convert provided user data to the direct path stream format.
OCI_EXPORT boolean OCI_API OCI_DateSetDate(OCI_Date *date, int year, int month, int day)
Set the date portion if the given date handle.
OCI_EXPORT int OCI_API OCI_DateDaysBetween(OCI_Date *date, OCI_Date *date2)
Return the number of days betWeen two dates.
void SetTimeZone(const ostring &timeZone)
Set the given time zone to the timestamp.
Collection Clone() const
Clone the current instance to a new one performing deep copy.
OCI_EXPORT unsigned int OCI_API OCI_GetVersionConnection(OCI_Connection *con)
Return the highest Oracle version is supported by the connection.
OCI_EXPORT unsigned int OCI_API OCI_BindGetDataSizeAtPos(OCI_Bind *bnd, unsigned int position)
Return the actual size of the element at the given position in the bind input array.
ostring GetTimeZone() const
Return the name of the current time zone.
OCI_EXPORT boolean OCI_API OCI_IsTAFCapable(OCI_Connection *con)
Verify if the given connection support TAF events.
static bool Initialized()
Return true if the environment has been successfully initialized.
OCI_EXPORT const void *OCI_API OCI_HandleGetEnvironment(void)
Return the OCI Environment Handle (OCIEnv *) of OCILIB library.
int GetInternalErrorCode() const
Return the OCILIB error code.
OCI_EXPORT int OCI_API OCI_MsgGetExpiration(OCI_Msg *msg)
Return the duration that the message is available for dequeuing.
int GetMilliSeconds() const
Return the interval seconds value.
static void Destroy(MutexHandle handle)
Destroy a mutex handle.
OCI_EXPORT boolean OCI_API OCI_BindDate(OCI_Statement *stmt, const otext *name, OCI_Date *data)
Bind a date variable.
unsigned int GetCount() const
Retrieve the number of rows fetched so far.
static OracleVersion GetRuntimeVersion()
Return the version of OCI used at runtime.
OCI_EXPORT boolean OCI_API OCI_CollFree(OCI_Coll *coll)
Free a local collection.
void AllowRebinding(bool value)
Allow different host variables to be binded using the same bind name or position between executions o...
OCI_EXPORT boolean OCI_API OCI_DateSysDate(OCI_Date *date)
Return the current system date/time into the date handle.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfRaws(OCI_Statement *stmt, const otext *name, void *data, unsigned int len, unsigned int nbelem)
Bind an array of raw buffers.
OCI_EXPORT OCI_Object *OCI_API OCI_RefGetObject(OCI_Ref *ref)
Returns the object pointed by the Ref handle.
void GetBatchErrors(std::vector< Exception > &exceptions)
Returns all errors that occurred within a DML array statement execution.
OCI_EXPORT OCI_Coll *OCI_API OCI_ElemGetColl(OCI_Elem *elem)
Return the collection value of the given collection element.
void Resume()
Resume a stopped global transaction.
struct OCI_Transaction OCI_Transaction
Oracle Transaction.
Definition: ocilib.h:537
void SetSeconds(int value)
Set the timestamp seconds value.
OCI_EXPORT unsigned int OCI_API OCI_CollGetCount(OCI_Coll *coll)
Returns the current number of elements of the given collection.
unsigned int GetPrefetchMemory() const
Return the amount of memory used to retrieve rows pre-fetched by OCI Client.
OCI_EXPORT OCI_Elem *OCI_API OCI_CollGetElem(OCI_Coll *coll, unsigned int index)
Return the element at the given position in the collection.
OCI_EXPORT boolean OCI_API OCI_ElemSetUnsignedInt(OCI_Elem *elem, unsigned int value)
Set a unsigned int value to a collection element.
OCI_EXPORT unsigned short OCI_API OCI_ObjectGetUnsignedShort(OCI_Object *obj, const otext *attr)
Return the unsigned short value of the given object attribute.
int GetSeconds() const
Return the date seconds value.
OCI_EXPORT const otext *OCI_API OCI_GetInstanceName(OCI_Connection *con)
Return the Oracle server Instance name of the connected database/service name.
OCI_EXPORT unsigned int OCI_API OCI_GetFetchMode(OCI_Statement *stmt)
Return the fetch mode of a SQL statement.
File Clone() const
Clone the current instance to a new one performing deep copy.
OCI_EXPORT boolean OCI_API OCI_SubscriptionAddStatement(OCI_Subscription *sub, OCI_Statement *stmt)
Add a statement to the notification to monitor.
OCI_EXPORT boolean OCI_API OCI_LobTruncate(OCI_Lob *lob, big_uint size)
Truncate the given lob to a shorter length.
void SetAddress(const ostring &value)
Set the given AQ agent address.
OCI_EXPORT void *OCI_API OCI_ThreadKeyGetValue(const otext *name)
Get a thread key value.
POCI_THREADKEYDEST ThreadKeyFreeProc
Thread Key callback for freeing resources.
Definition: ocilib.hpp:1391
void SetDay(int value)
Set the timestamp day value.
unsigned int GetBindCount() const
Return the number of binds currently associated to a statement.
Message(const TypeInfo &typeInfo)
Create a message object based on the given payload type.
OCI_EXPORT boolean OCI_API OCI_LobClose(OCI_Lob *lob)
Close explicitly a Lob.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfDates(OCI_Statement *stmt, const otext *name, OCI_Date **data, unsigned int nbelem)
Bind an array of dates.
bool Prev()
Fetch the previous row of the resultset.
OCI_EXPORT OCI_Interval *OCI_API OCI_GetInterval2(OCI_Resultset *rs, const otext *name)
Return the current interval value of the column from its name in the resultset.
void SetTimeout(unsigned int value)
Set the connections/sessions idle timeout.
OCI_EXPORT boolean OCI_API OCI_CollSetElem(OCI_Coll *coll, unsigned int index, OCI_Elem *elem)
Assign the given element value to the element at the given position in the collection.
void SetMode(DequeueMode value)
Set the dequeuing/locking behavior.
LobType GetType() const
return the type of lob
OCI_EXPORT boolean OCI_API OCI_DirPathAbort(OCI_DirPath *dp)
Terminate a direct path operation without committing changes.
OCI_EXPORT boolean OCI_API OCI_CollAppend(OCI_Coll *coll, OCI_Elem *elem)
Append the given element at the end of the collection.
OCI_EXPORT boolean OCI_API OCI_ElemSetUnsignedBigInt(OCI_Elem *elem, big_uint value)
Set a unsigned big_int value to a collection element.
OCI_EXPORT boolean OCI_API OCI_BindLob(OCI_Statement *stmt, const otext *name, OCI_Lob *data)
Bind a Lob variable.
Connection GetConnection() const
Return the file parent connection.
OCI_EXPORT boolean OCI_API OCI_RegisterDouble(OCI_Statement *stmt, const otext *name)
Register a double output bind placeholder.
OCI_EXPORT unsigned int OCI_API OCI_GetColumnCount(OCI_Resultset *rs)
Return the number of columns in the resultset.
OCI_EXPORT unsigned int OCI_API OCI_DirPathGetErrorColumn(OCI_DirPath *dp)
Return the index of a column which caused an error during data conversion.
OCI_EXPORT unsigned int OCI_API OCI_ColumnGetCharsetForm(OCI_Column *col)
Return the charset form of the given column.
void(* POCI_NOTIFY)(OCI_Event *event)
Database Change Notification User callback prototype.
Definition: ocilib.h:839
static void Start(const Connection &connection, const ostring &queue, bool enableEnqueue=true, bool enableDequeue=true)
Start the given queue.
ostring ToString() const override
Convert the number value to a string using default format OCI_STRING_FORMAT_NUMERIC.
OCI_EXPORT boolean OCI_API OCI_AllowRebinding(OCI_Statement *stmt, boolean value)
Allow different host variables to be binded using the same bind name or position between executions o...
OCI_EXPORT boolean OCI_API OCI_Describe(OCI_Statement *stmt, const otext *sql)
Describe the select list of a SQL select statement.
OCI_EXPORT const otext *OCI_API OCI_BindGetName(OCI_Bind *bnd)
Return the name of the given bind.
void UpdateTimeZone(const ostring &timeZone)
Update the interval value with the given time zone.
OCI_EXPORT boolean OCI_API OCI_ServerEnableOutput(OCI_Connection *con, unsigned int bufsize, unsigned int arrsize, unsigned int lnsize)
Enable the server output.
bool operator!=(const Date &other) const
Indicates if the current date value is not equal the given date value.
OCI_EXPORT unsigned int OCI_API OCI_LobAppend(OCI_Lob *lob, void *buffer, unsigned int len)
Append a buffer at the end of a LOB.
OCI_EXPORT unsigned int OCI_API OCI_GetMaxCursors(OCI_Connection *con)
Return the maximum number of SQL statements that can be opened in one session.
OCI_EXPORT boolean OCI_API OCI_LobCopy(OCI_Lob *lob, OCI_Lob *lob_src, big_uint offset_dst, big_uint offset_src, big_uint count)
Copy a portion of a source LOB into a destination LOB.
OCI_EXPORT boolean OCI_API OCI_MsgSetSender(OCI_Msg *msg, OCI_Agent *sender)
Set the original sender of a message.
OCI_EXPORT const otext *OCI_API OCI_GetSQLVerb(OCI_Statement *stmt)
Return the verb of the SQL command held by the statement handle.
int GetMinutes() const
Return the interval minutes value.
OCI_EXPORT const otext *OCI_API OCI_ErrorGetString(OCI_Error *err)
Retrieve error message from error handle.
void SetInfos(const ostring &directory, const ostring &name)
Set the directory and file name of our file object.
struct OCI_Resultset OCI_Resultset
Collection of output columns from a select statement.
Definition: ocilib.h:462
OCI_EXPORT const otext *OCI_API OCI_GetDomainName(OCI_Connection *con)
Return the Oracle server domain name of the connected database/service name.
OCI_EXPORT boolean OCI_API OCI_ObjectIsNull(OCI_Object *obj, const otext *attr)
Check if an object attribute is null.
OCI_EXPORT int OCI_API OCI_DequeueGetWaitTime(OCI_Dequeue *dequeue)
Return the time that OCIDequeueGet() waits for messages if no messages are currently available...
OCI_EXPORT boolean OCI_API OCI_Execute(OCI_Statement *stmt)
Execute a prepared SQL statement or PL/SQL block.
DataType GetType() const
Return the OCILIB type of the data associated with the bind object.
void SetStatementCacheSize(unsigned int value)
Set the maximum number of statements to keep in the statement cache.
unsigned int GetMaxCursors() const
Return the maximum number of SQL statements that can be opened in one session.
OCI_EXPORT boolean OCI_API OCI_ObjectFree(OCI_Object *obj)
Free a local object.
OCI_EXPORT boolean OCI_API OCI_ElemSetFile(OCI_Elem *elem, OCI_File *value)
Assign a File handle to a collection element.
Allow resolving a the C API numeric enumerated type from a C++ type.
FetchMode GetFetchMode() const
Return the fetch mode of a SQL statement.
SessionFlagsValues
Session flags enumerated values.
Definition: ocilib.hpp:749
TransactionFlagsValues
Transaction flags enumerated values.
Definition: ocilib.hpp:2394
OCI_EXPORT OCI_Error *OCI_API OCI_GetLastError(void)
Retrieve the last error or warning occurred within the last OCILIB call.
OCI_EXPORT boolean OCI_API OCI_TransactionPrepare(OCI_Transaction *trans)
Prepare a global transaction validation.
OCI_EXPORT const otext *OCI_API OCI_FileGetDirectory(OCI_File *file)
Return the directory of the given file.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfInts(OCI_Statement *stmt, const otext *name, int *data, unsigned int nbelem)
Bind an array of integers.
void AddDays(int days)
Add or subtract days.
unsigned int GetIncrement() const
Return the increment for connections/sessions to be opened to the database when the pool is not full...
void GetDate(int &year, int &month, int &day) const
Extract the date parts.
OCI_EXPORT unsigned int OCI_API OCI_DirPathGetAffectedRows(OCI_DirPath *dp)
return the number of rows successfully processed during in the last conversion or loading call ...
OCI_EXPORT OCI_Date *OCI_API OCI_MsgGetEnqueueTime(OCI_Msg *msg)
return the time the message was enqueued
ostring GetName() const
Get the given AQ agent name.
T Get(unsigned int index) const
Return the collection element value at the given position.
OCI_EXPORT boolean OCI_API OCI_BindBoolean(OCI_Statement *stmt, const otext *name, boolean *data)
Bind a boolean variable (PL/SQL ONLY)
static void Destroy(ThreadHandle handle)
Destroy a thread.
OCI_EXPORT int OCI_API OCI_GetInt(OCI_Resultset *rs, unsigned int index)
Return the current integer value of the column at the given index in the resultset.
BindInfo GetBind(unsigned int index) const
Return the bind at the given index in the internal array of bind objects.
bool operator>=(const Date &other) const
Indicates if the current date value is superior or equal to the given date value. ...
void SetTime(int hour, int min, int sec)
Set the time part.
OCI_EXPORT unsigned int OCI_API OCI_GetCurrentRow(OCI_Resultset *rs)
Retrieve the current row number.
OCI_EXPORT OCI_Connection *OCI_API OCI_SubscriptionGetConnection(OCI_Subscription *sub)
Return the connection handle associated with a subscription handle.
OCI_EXPORT boolean OCI_API OCI_ObjectSetUnsignedInt(OCI_Object *obj, const otext *attr, unsigned int value)
Set an object attribute of type unsigned int.
OCI_EXPORT float OCI_API OCI_GetFloat2(OCI_Resultset *rs, const otext *name)
Return the current float value of the column from its name in the resultset.
void GetYearMonth(int &year, int &month) const
Extract the year / month parts from the interval value.
OCI_EXPORT big_int OCI_API OCI_GetBigInt2(OCI_Resultset *rs, const otext *name)
Return the current big integer value of the column from its name in the resultset.
unsigned int GetTimeout() const
Return the timeout of the given registered subscription.
unsigned int GetStatementCacheSize() const
Return the maximum number of statements to keep in the statement cache.
Long< ostring, LongCharacter > Clong
Class handling LONG oracle type.
Definition: ocilib_impl.hpp:49
OCI_EXPORT boolean OCI_API OCI_DirPathSetCurrentRows(OCI_DirPath *dp, unsigned int nb_rows)
Set the current number of rows to convert and load.
void Start()
Start global transaction.
OCI_EXPORT boolean OCI_API OCI_MsgGetRaw(OCI_Msg *msg, void *raw, unsigned int *size)
Get the RAW payload of the given message.
TransactionFlags GetFlags() const
Return the transaction mode.
Raw Read(unsigned int size)
Read a portion of a file.
OCI_EXPORT boolean OCI_API OCI_MutexRelease(OCI_Mutex *mutex)
Release a mutex lock.
void SetMilliSeconds(int value)
Set the timestamp milliseconds value.
OCI_EXPORT boolean OCI_API OCI_TimestampConstruct(OCI_Timestamp *tmsp, int year, int month, int day, int hour, int min, int sec, int fsec, const otext *time_zone)
Set a timestamp handle value.
OCI_EXPORT boolean OCI_API OCI_TimestampSubtract(OCI_Timestamp *tmsp, OCI_Timestamp *tmsp2, OCI_Interval *itv)
Store the difference of two timestamp handles into an interval handle.
void SetVisibility(DequeueVisibility value)
Set whether the new message is dequeued as part of the current transaction.
static AnyPointer GetValue(const ostring &name)
Get a thread key value.
OCI_EXPORT int OCI_API OCI_MsgGetPriority(OCI_Msg *msg)
Return the priority of the message.
void DisableServerOutput()
Disable the server output.
OCI_EXPORT boolean OCI_API OCI_DateZoneToZone(OCI_Date *date, const otext *zone1, const otext *zone2)
Convert a date from one zone to another zone.
bool operator==(const Timestamp &other) const
Indicates if the current Timestamp value is equal to the given Timestamp value.
OCI_EXPORT unsigned int OCI_API OCI_CollGetSize(OCI_Coll *coll)
Returns the total number of elements of the given collection.
unsigned int GetBindArraySize() const
Return the current input array size for bulk operations.
OCI_EXPORT const void *OCI_API OCI_HandleGetThreadID(OCI_Thread *thread)
Return OCI Thread ID (OCIThreadId *) of an OCILIB OCI_Thread object.
MessageState GetState() const
Return the state of the message at the time of the dequeue.
OCI_EXPORT boolean OCI_API OCI_MsgFree(OCI_Msg *msg)
Free a message object.
void GetDaySecond(int &day, int &hour, int &min, int &sec, int &fsec) const
Extract the date / second parts from the interval value.
void SetColumn(unsigned int colIndex, const ostring &name, unsigned int maxSize, const ostring &format=OTEXT(""))
Describe a column to load into the given table.
OCI_EXPORT boolean OCI_API OCI_RegisterUnsignedInt(OCI_Statement *stmt, const otext *name)
Register an unsigned integer output bind placeholder.
static void Substract(const Timestamp &lsh, const Timestamp &rsh, Interval &result)
Subtract the given two timestamp and store the result into the given Interval.
OCI_EXPORT boolean OCI_API OCI_EnqueueSetVisibility(OCI_Enqueue *enqueue, unsigned int visibility)
Set whether the new message is enqueued as part of the current transaction.
OCI_EXPORT unsigned int OCI_API OCI_PoolGetBusyCount(OCI_Pool *pool)
Return the current number of busy connections/sessions.
OCI_EXPORT OCI_Connection *OCI_API OCI_ConnectionCreate(const otext *db, const otext *user, const otext *pwd, unsigned int mode)
Create a physical connection to an Oracle database server.
IntervalType GetType() const
Return the type of the given interval object.
OCI_EXPORT double OCI_API OCI_GetDouble(OCI_Resultset *rs, unsigned int index)
Return the current double value of the column at the given index in the resultset.
OCI_EXPORT boolean OCI_API OCI_CollAssign(OCI_Coll *coll, OCI_Coll *coll_src)
Assign a collection to another one.
unsigned int GetSqlErrorPos() const
Return the error position (in terms of characters) in the SQL statement where the error occurred in c...
OCI_EXPORT unsigned int OCI_API OCI_SubscriptionGetTimeout(OCI_Subscription *sub)
Return the timeout of the given registered subscription.
OCI_EXPORT OCI_Agent *OCI_API OCI_MsgGetSender(OCI_Msg *msg)
Return the original sender of a message.
static OracleVersion GetCompileVersion()
Return the version of OCI used for compiling OCILIB.
void Finish()
Terminate a direct path operation and commit changes into the database.
OCI_EXPORT boolean OCI_API OCI_SetHAHandler(POCI_HA_HANDLER handler)
Set the High availability (HA) user handler.
DirectPath::Result Convert()
Convert provided user data to the direct path stream format.
Interval & operator-=(const Interval &other)
Decrement the current Value with the given Interval value.
OCI_EXPORT boolean OCI_API OCI_DateToText(OCI_Date *date, const otext *fmt, int size, otext *str)
Convert a Date value from the given date handle to a string.
OCI_EXPORT short OCI_API OCI_ElemGetShort(OCI_Elem *elem)
Return the short value of the given collection element.
Enqueue(const TypeInfo &typeInfo, const ostring &queueName)
Create a Enqueue object for the given queue.
Dequeue(const TypeInfo &typeInfo, const ostring &queueName)
Parametrized constructor.
static void SetValue(const ostring &name, AnyPointer value)
Set a thread key value.
OCI_EXPORT const otext *OCI_API OCI_EventGetDatabase(OCI_Event *event)
Return the name of the database that generated the event.
OCI_EXPORT boolean OCI_API OCI_RegisterObject(OCI_Statement *stmt, const otext *name, OCI_TypeInfo *typinf)
Register an object output bind placeholder.
OCI_EXPORT boolean OCI_API OCI_ObjectSetBigInt(OCI_Object *obj, const otext *attr, big_int value)
Set an object attribute of type big int.
Connection GetConnection() const
Return the connection associated with a statement.
struct OCI_File OCI_File
Oracle External Large objects:
Definition: ocilib.h:522
OCI_EXPORT OCI_Lob *OCI_API OCI_LobCreate(OCI_Connection *con, unsigned int type)
Create a local temporary Lob instance.
static MutexHandle Create()
Create a Mutex handle.
ostring ToString() const override
Convert the timestamp value to a string using default date format and no precision.
OCI_EXPORT const otext *OCI_API OCI_GetDatabase(OCI_Connection *con)
Return the name of the connected database/service name.
OCI_EXPORT boolean OCI_API OCI_IntervalAdd(OCI_Interval *itv, OCI_Interval *itv2)
Adds an interval handle value to another.
bool operator==(const Date &other) const
Indicates if the current date value is equal to the given date value.
OCI_EXPORT boolean OCI_API OCI_BindTimestamp(OCI_Statement *stmt, const otext *name, OCI_Timestamp *data)
Bind a timestamp variable.
OCI_EXPORT boolean OCI_API OCI_SetTrace(OCI_Connection *con, unsigned int trace, const otext *value)
Set tracing information to the session of the given connection.
void GetTime(int &hour, int &min, int &sec) const
Extract time parts.
OCI_EXPORT boolean OCI_API OCI_ObjectSetDate(OCI_Object *obj, const otext *attr, OCI_Date *value)
Set an object attribute of type Date.
bool operator<(const Interval &other) const
Indicates if the current Interval value is inferior to the given Interval value.
void SetDataNull(bool value, unsigned int index=1)
Mark as null or not null the current bind real value(s) used in SQL statements.
unsigned int GetDataCount() const
Return the number of elements associated with the bind object.
void Prepare()
Prepares the OCI direct path load interface before any rows can be converted or loaded.
void GetDateTime(int &year, int &month, int &day, int &hour, int &min, int &sec) const
Extract the date and time parts.
OCI_EXPORT boolean OCI_API OCI_FetchNext(OCI_Resultset *rs)
Fetch the next row of the resultset.
OCI_EXPORT float OCI_API OCI_GetFloat(OCI_Resultset *rs, unsigned int index)
Return the current float value of the column at the given index in the resultset. ...
OCI_EXPORT const otext *OCI_API OCI_GetFormat(OCI_Connection *con, unsigned int type)
Return the format string for implicit string conversions of the given type.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfFiles(OCI_Statement *stmt, const otext *name, OCI_File **data, unsigned int type, unsigned int nbelem)
Bind an array of File handles.
OCI_EXPORT boolean OCI_API OCI_MsgSetRaw(OCI_Msg *msg, const void *raw, unsigned int size)
Set the RAW payload of the given message.
OCI_EXPORT boolean OCI_API OCI_MsgSetConsumers(OCI_Msg *msg, OCI_Agent **consumers, unsigned int count)
Set the recipient list of a message to enqueue.
Date & operator--()
Decrement the date by 1 day.
OCI_EXPORT boolean OCI_API OCI_RegisterNumber(OCI_Statement *stmt, const otext *name)
Register a register output bind placeholder.
OCI_EXPORT boolean OCI_API OCI_QueueTableMigrate(OCI_Connection *con, const otext *queue_table, const otext *compatible)
Migrate a queue table from one version to another.
OCI_EXPORT boolean OCI_API OCI_ObjectSetTimestamp(OCI_Object *obj, const otext *attr, OCI_Timestamp *value)
Set an object attribute of type Timestamp.
static unsigned int GetRuntimeRevisionVersion()
Return the revision version number of OCI used at runtime.
OCI_EXPORT boolean OCI_API OCI_RegisterLob(OCI_Statement *stmt, const otext *name, unsigned int type)
Register a lob output bind placeholder.
OCI_EXPORT boolean OCI_API OCI_ThreadFree(OCI_Thread *thread)
Destroy a thread object.
static void Drop(const Connection &connection, const ostring &table, bool force=true)
Drop the given queue table.
DequeueMode GetMode() const
Get the dequeuing/locking behavior.
OCI_EXPORT boolean OCI_API OCI_TimestampIntervalAdd(OCI_Timestamp *tmsp, OCI_Interval *itv)
Add an interval value to a timestamp value of a timestamp handle.
OCI_EXPORT OCI_Date *OCI_API OCI_ObjectGetDate(OCI_Object *obj, const otext *attr)
Return the date value of the given object attribute.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfStrings(OCI_Statement *stmt, const otext *name, otext *data, unsigned int len, unsigned int nbelem)
Bind an array of strings.
OCI_EXPORT boolean OCI_API OCI_ObjectGetSelfRef(OCI_Object *obj, OCI_Ref *ref)
Retrieve an Oracle Ref handle from an object and assign it to the given OCILIB OCI_Ref handle...
bool IsTAFCapable() const
Verify if the connection support TAF events.
unsigned int Write(const T &content)
Write the given string into the long Object.
void SetOriginalID(const Raw &value)
Set the original ID of the message in the last queue that generated this message. ...
big_uint GetLength() const
Returns the number of characters or bytes contained in the lob.
OCI_EXPORT boolean OCI_API OCI_PoolFree(OCI_Pool *pool)
Destroy a pool object.
ostring GetCorrelation() const
Get the correlation identifier of the message.
OCI_EXPORT boolean OCI_API OCI_ElemSetNumber(OCI_Elem *elem, OCI_Number *value)
Set a number value to a collection element.
OCI_EXPORT OCI_Coll *OCI_API OCI_CollCreate(OCI_TypeInfo *typinf)
Create a local collection instance.
bool IsRebindingAllowed() const
Indicate if rebinding is allowed on the statement.
OCI_EXPORT unsigned int OCI_API OCI_GetFetchSize(OCI_Statement *stmt)
Return the number of rows fetched per internal server fetch call.
Connection GetConnection() const
Return the connection associated with a subscription handle.
void SetMonth(int value)
Set the timestamp month value.
OCI_EXPORT boolean OCI_API OCI_ColumnGetNullable(OCI_Column *col)
Return the nullable attribute of the column.
OCI_EXPORT const otext *OCI_API OCI_FileGetName(OCI_File *file)
Return the name of the given file.
OCI_EXPORT unsigned int OCI_API OCI_GetStatementType(OCI_Statement *stmt)
Return the type of a SQL statement.
OCI_EXPORT boolean OCI_API OCI_QueueCreate(OCI_Connection *con, const otext *queue_name, const otext *queue_table, unsigned int queue_type, unsigned int max_retries, unsigned int retry_delay, unsigned int retention_time, boolean dependency_tracking, const otext *comment)
Create a queue.
OCI_EXPORT unsigned int OCI_API OCI_GetRaw(OCI_Resultset *rs, unsigned int index, void *buffer, unsigned int len)
Copy the current raw value of the column at the given index into the specified buffer.
OCI_EXPORT boolean OCI_API OCI_FileSeek(OCI_File *file, big_uint offset, unsigned int mode)
Perform a seek operation on the OCI_File content buffer.
bool operator+=(int offset)
Convenient operator overloading that performs a call to Seek() with Resultset::SeekRelative and the g...
OCI_EXPORT boolean OCI_API OCI_SetAutoCommit(OCI_Connection *con, boolean enable)
Enable / disable auto commit mode.
OCI_EXPORT boolean OCI_API OCI_LobIsTemporary(OCI_Lob *lob)
Check if the given lob is a temporary lob.
OCI_EXPORT boolean OCI_API OCI_DirPathSetColumn(OCI_DirPath *dp, unsigned int index, const otext *name, unsigned int maxsize, const otext *format)
Describe a column to load into the given table.
OCI_EXPORT boolean OCI_API OCI_NumberSetValue(OCI_Number *number, unsigned int type, void *value)
Assign the number value with the value of a native C numeric type.
OCI_EXPORT boolean OCI_API OCI_DirPathSetNoLog(OCI_DirPath *dp, boolean value)
Set the logging mode for the loading operation.
OCI_EXPORT boolean OCI_API OCI_IsConnected(OCI_Connection *con)
Returns TRUE is the given connection is still connected otherwise FALSE.
static void SetHAHandler(HAHandlerProc handler)
Set the High availability (HA) user handler.
OCI_EXPORT boolean OCI_API OCI_QueueTableCreate(OCI_Connection *con, const otext *queue_table, const otext *queue_payload_type, const otext *storage_clause, const otext *sort_list, boolean multiple_consumers, unsigned int message_grouping, const otext *comment, unsigned int primary_instance, unsigned int secondary_instance, const otext *compatible)
Create a queue table for messages of the given type.
OCI_EXPORT OCI_Bind *OCI_API OCI_GetBind2(OCI_Statement *stmt, const otext *name)
Return a bind handle from its name.
OCI_EXPORT boolean OCI_API OCI_Prepare(OCI_Statement *stmt, const otext *sql)
Prepare a SQL statement or PL/SQL block.
OCI_EXPORT boolean OCI_API OCI_DequeueSetAgentList(OCI_Dequeue *dequeue, OCI_Agent **consumers, unsigned int count)
Set the Agent list to listen to message for.
OCI_EXPORT boolean OCI_API OCI_PoolSetTimeout(OCI_Pool *pool, unsigned int value)
Set the connections/sessions idle timeout.
void SetDate(int year, int month, int day)
Set the date part.
OCI_EXPORT OCI_File *OCI_API OCI_GetFile(OCI_Resultset *rs, unsigned int index)
Return the current File value of the column at the given index in the resultset.
OCI_EXPORT boolean OCI_API OCI_DateSetDateTime(OCI_Date *date, int year, int month, int day, int hour, int min, int sec)
Set the date and time portions if the given date handle.
Connection GetConnection(const ostring &sessionTag=OTEXT(""))
Get a connection from the pool.
OCI_EXPORT boolean OCI_API OCI_ObjectSetInt(OCI_Object *obj, const otext *attr, int value)
Set an object attribute of type int.
ostring GetSessionTag() const
Return the tag associated with the given connection.
OCI_EXPORT big_uint OCI_API OCI_LobGetLength(OCI_Lob *lob)
Return the actual length of a lob.
OCI_EXPORT unsigned int OCI_API OCI_GetServerMajorVersion(OCI_Connection *con)
Return the major version number of the connected database server.
OCI_EXPORT boolean OCI_API OCI_DirPathSetEntry(OCI_DirPath *dp, unsigned int row, unsigned int index, void *value, unsigned size, boolean complete)
Set the value of the given row/column array entry.
OCI_EXPORT OCI_Lob *OCI_API OCI_ElemGetLob(OCI_Elem *elem)
Return the Lob value of the given collection element.
bool operator!=(const File &other) const
Indicates if the current file value is not equal the given file value.
OCI_EXPORT boolean OCI_API OCI_LobEnableBuffering(OCI_Lob *lob, boolean value)
Enable / disable buffering mode on the given lob handle.
OCI_EXPORT unsigned int OCI_API OCI_GetStatementCacheSize(OCI_Connection *con)
Return the maximum number of statements to keep in the statement cache.
void SetConsumers(std::vector< Agent > &agents)
Set the recipient list of a message to enqueue.
OCI_EXPORT boolean OCI_API OCI_SetTransaction(OCI_Connection *con, OCI_Transaction *trans)
Set a transaction to a connection.
OCI_EXPORT boolean OCI_API OCI_CollTrim(OCI_Coll *coll, unsigned int nb_elem)
Trims the given number of elements from the end of the collection.
void Open(const ostring &db, const ostring &user, const ostring &pwd, Environment::SessionFlags sessionFlags=Environment::SessionDefault)
Create a physical connection to an Oracle database server.
OCI_EXPORT boolean OCI_API OCI_RefFree(OCI_Ref *ref)
Free a local Ref.
OCI_EXPORT OCI_Transaction *OCI_API OCI_GetTransaction(OCI_Connection *con)
Return the current transaction of the connection.
AnyPointer GetUserData()
Return the pointer to user data previously associated with the connection.
void SetLongMode(LongMode value)
Set the long data type handling mode of a SQL statement.
OCI_EXPORT boolean OCI_API OCI_DateNextDay(OCI_Date *date, const otext *day)
Gets the date of next day of the week, after a given date.
OCI_EXPORT boolean OCI_API OCI_Rollback(OCI_Connection *con)
Cancel current pending changes.
Template class providing OCILIB handles auto memory, life cycle and scope management.
OCI_EXPORT OCI_TypeInfo *OCI_API OCI_ObjectGetTypeInfo(OCI_Object *obj)
Return the type info object associated to the object.
OCI_EXPORT unsigned int OCI_API OCI_LongGetSize(OCI_Long *lg)
Return the buffer size of a long object in bytes (OCI_BLONG) or character (OCI_CLONG) ...
big_uint GetOffset() const
Returns the current R/W offset within the lob.
OCI_EXPORT boolean OCI_API OCI_FileOpen(OCI_File *file)
Open a file for reading.
OCI_EXPORT boolean OCI_API OCI_FetchSeek(OCI_Resultset *rs, unsigned int mode, int offset)
Custom Fetch of the resultset.
Timestamp()
Create an empty null timestamp instance.
OCI_EXPORT boolean OCI_API OCI_IntervalGetYearMonth(OCI_Interval *itv, int *year, int *month)
Return the year / month portion of an interval handle.
Collection()
Create an empty null Collection instance.
OCI_EXPORT boolean OCI_API OCI_IntervalSetDaySecond(OCI_Interval *itv, int day, int hour, int min, int sec, int fsec)
Set the day / time portion if the given interval handle.
Pool()
Default constructor.
void Prepare(const ostring &sql)
Prepare a SQL statement or PL/SQL block.
Template Flags template class providing some type safety to some extends for manipulating flags set v...
OCI_EXPORT boolean OCI_API OCI_ElemSetColl(OCI_Elem *elem, OCI_Coll *value)
Assign a Collection handle to a collection element.
OCI_EXPORT unsigned int OCI_API OCI_DequeueGetVisibility(OCI_Dequeue *dequeue)
Get the dequeuing/locking behavior.
OCI_EXPORT boolean OCI_API OCI_ElemSetDate(OCI_Elem *elem, OCI_Date *value)
Assign a Date handle to a collection element.
OCI_EXPORT boolean OCI_API OCI_ObjectSetUnsignedShort(OCI_Object *obj, const otext *attr, unsigned short value)
Set an object attribute of type unsigned short.
void GetTime(int &hour, int &min, int &sec, int &fsec) const
Extract time parts.
OCI_EXPORT unsigned int OCI_API OCI_GetDataLength(OCI_Resultset *rs, unsigned int index)
Return the current row data length of the column at the given index in the resultset.
void SetDay(int value)
Set the interval day value.
Date Clone() const
Clone the current instance to a new one performing deep copy.
OCI_EXPORT boolean OCI_API OCI_RegisterString(OCI_Statement *stmt, const otext *name, unsigned int len)
Register a string output bind placeholder.
OCI_EXPORT boolean OCI_API OCI_RegisterShort(OCI_Statement *stmt, const otext *name)
Register a short output bind placeholder.
void Commit()
Commit current pending changes.
OCI_Thread * ThreadHandle
Alias for an OCI_Thread pointer.
Definition: ocilib.hpp:196
OCI_EXPORT OCI_Object *OCI_API OCI_ElemGetObject(OCI_Elem *elem)
Return the object value of the given collection element.
OCI_EXPORT unsigned int OCI_API OCI_GetSQLCommand(OCI_Statement *stmt)
Return the Oracle SQL code the command held by the statement handle.
OCI_EXPORT unsigned int OCI_API OCI_DirPathGetRowCount(OCI_DirPath *dp)
Return the number of rows successfully loaded into the database so far.
unsigned int GetMinSize() const
Return the minimum number of connections/sessions that can be opened to the database.
bool SetFormat(FormatType formatType, const ostring &format)
Set the format string for implicit string conversions of the given type.
void Break()
Perform an immediate abort of any currently Oracle OCI call on the given connection.
OCI_EXPORT boolean OCI_API OCI_TimestampAssign(OCI_Timestamp *tmsp, OCI_Timestamp *tmsp_src)
Assign the value of a timestamp handle to another one.
static void StartDatabase(const ostring &db, const ostring &user, const ostring &pwd, Environment::StartFlags startFlags, Environment::StartMode startMode, Environment::SessionFlags sessionFlags=SessionSysDba, const ostring &spfile=OTEXT(""))
Start a database instance.
unsigned int GetMax() const
Returns the maximum number of elements for the collection.
OCI_EXPORT boolean OCI_API OCI_DirPathSetConvertMode(OCI_DirPath *dp, unsigned int mode)
Set the direct path conversion mode.
void Unsubscribe()
Unsubscribe for asynchronous messages notifications.
OCI_EXPORT int OCI_API OCI_ColumnGetFractionalPrecision(OCI_Column *col)
Return the fractional precision of the column for timestamp and interval columns. ...
void SetYear(int value)
Set the timestamp year value.
OCI_EXPORT unsigned int OCI_API OCI_GetPrefetchMemory(OCI_Statement *stmt)
Return the amount of memory used to retrieve rows pre-fetched by OCI Client.
OCI_EXPORT boolean OCI_API OCI_SetPrefetchSize(OCI_Statement *stmt, unsigned int size)
Set the number of rows pre-fetched by OCI Client.
OCI_EXPORT boolean OCI_API OCI_DequeueGetRelativeMsgID(OCI_Dequeue *dequeue, void *id, unsigned int *len)
Get the message identifier of the message to be dequeued.
OCI_EXPORT boolean OCI_API OCI_DirPathSetParallel(OCI_DirPath *dp, boolean value)
Set the parallel loading mode.
OCI_EXPORT boolean OCI_API OCI_DequeueSetCorrelation(OCI_Dequeue *dequeue, const otext *pattern)
set the correlation identifier of the message to be dequeued
OCI_EXPORT int OCI_API OCI_NumberAssign(OCI_Number *number, OCI_Number *number_src)
Assign the value of a number handle to another one.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfRefs(OCI_Statement *stmt, const otext *name, OCI_Ref **data, OCI_TypeInfo *typinf, unsigned int nbelem)
Bind an array of Ref handles.
OCI_EXPORT boolean OCI_API OCI_QueueAlter(OCI_Connection *con, const otext *queue_name, unsigned int max_retries, unsigned int retry_delay, unsigned int retention_time, const otext *comment)
Alter the given queue.
std::vector< unsigned char > Raw
C++ counterpart of SQL RAW data type.
Definition: ocilib.hpp:178
OCI_EXPORT OCI_Dequeue *OCI_API OCI_DequeueCreate(OCI_TypeInfo *typinf, const otext *name)
Create a Dequeue object for the given queue.
OCI_EXPORT OCI_Error *OCI_API OCI_GetBatchError(OCI_Statement *stmt)
Returns the first or next error that occurred within a DML array statement execution.
ostring GetName() const
Return the type info name.
Date operator-(int value) const
Return a new date holding the current date value decremented by the given number of days...
OCI_EXPORT OCI_Resultset *OCI_API OCI_GetNextResultset(OCI_Statement *stmt)
Retrieve the next available resultset.
OCI_EXPORT unsigned int OCI_API OCI_TransactionGetTimeout(OCI_Transaction *trans)
Return global transaction Timeout.
OCI_EXPORT boolean OCI_API OCI_ElemSetInt(OCI_Elem *elem, int value)
Set a int value to a collection element.
OCI_EXPORT boolean OCI_API OCI_LongFree(OCI_Long *lg)
Free a local temporary long.
struct OCI_Long OCI_Long
Oracle Long data type.
Definition: ocilib.h:559
OCI_EXPORT double OCI_API OCI_ElemGetDouble(OCI_Elem *elem)
Return the Double value of the given collection element.
Statement()
Create an empty null Statement instance.
ostring GetDomain() const
Return the Oracle server Domain name of the connected database/service name.
Agent GetSender() const
Return the original sender of the message.
OCI_EXPORT boolean OCI_API OCI_RegisterRef(OCI_Statement *stmt, const otext *name, OCI_TypeInfo *typinf)
Register a Ref output bind placeholder.
OCI_EXPORT boolean OCI_API OCI_TimestampToText(OCI_Timestamp *tmsp, const otext *fmt, int size, otext *str, int precision)
Convert a timestamp value from the given timestamp handle to a string.
int GetMilliSeconds() const
Return the timestamp seconds value.
OCI_EXPORT short OCI_API OCI_GetShort(OCI_Resultset *rs, unsigned int index)
Return the current short value of the column at the given index in the resultset. ...
void SetWaitTime(int value)
Set the time that Get() waits for messages if no messages are currently available.
Raw GetID() const
Return the ID of the message.
iterator end()
Returns an iterator referring to the past-the-end element in the collection.
Provides type information on Oracle Database objects.
Definition: ocilib.hpp:4523
OCI_EXPORT boolean OCI_API OCI_SetPrefetchMemory(OCI_Statement *stmt, unsigned int size)
Set the amount of memory pre-fetched by OCI Client.
OCI_EXPORT OCI_Column *OCI_API OCI_TypeInfoGetColumn(OCI_TypeInfo *typinf, unsigned int index)
Return the column object handle at the given index in the table.
ostring GetName() const
Return the file name.
OCI_EXPORT OCI_Number *OCI_API OCI_GetNumber(OCI_Resultset *rs, unsigned int index)
Return the current Number value of the column at the given index in the resultset.
OCI_EXPORT const otext *OCI_API OCI_EventGetRowid(OCI_Event *event)
Return the rowid of the altered database object row.
struct OCI_TypeInfo OCI_TypeInfo
Type info metadata handle.
Definition: ocilib.h:665
EnqueueVisibility GetVisibility() const
Get the enqueuing/locking behavior.
OCI_EXPORT unsigned int OCI_API OCI_DirPathGetErrorRow(OCI_DirPath *dp)
Return the index of a row which caused an error during data conversion.
OCI_EXPORT boolean OCI_API OCI_ObjectGetBoolean(OCI_Object *obj, const otext *attr)
Return the boolean value of the given object attribute (ONLY for PL/SQL records)
TypeInfoType GetType() const
Return the type of the given TypeInfo object.
void Rollback()
Cancel current pending changes.
void SetCurrentRows(unsigned int value)
Set the current number of rows to convert and load.
OCI_EXPORT const otext *OCI_API OCI_ElemGetString(OCI_Elem *elem)
Return the String value of the given collection element.
ostring GetSQLType() const
Return the Oracle SQL type name of the column data type.
OCI_EXPORT const otext *OCI_API OCI_GetServiceName(OCI_Connection *con)
Return the Oracle server service name of the connected database/service name.
OCI_EXPORT OCI_Object *OCI_API OCI_MsgGetObject(OCI_Msg *msg)
Get the object payload of the given message.
Resolve a bind input / output types.
Definition: ocilib_impl.hpp:68
unsigned int GetColumnCount() const
Return the number of columns contained in the type.
OCI_EXPORT boolean OCI_API OCI_BindShort(OCI_Statement *stmt, const otext *name, short *data)
Bind an short variable.
OCI_EXPORT boolean OCI_API OCI_ElemSetDouble(OCI_Elem *elem, double value)
Set a double value to a collection element.
OCI_EXPORT const otext *OCI_API OCI_DequeueGetConsumer(OCI_Dequeue *dequeue)
Get the current consumer name associated with the dequeuing process.
DirectPath::Result Load()
Loads the data converted to direct path stream format.
int GetEnqueueDelay() const
Return the number of seconds that a message is delayed for dequeuing.
IntervalTypeValues
Interval types enumerated values.
Definition: ocilib.hpp:3130
OCI_EXPORT boolean OCI_API OCI_ElemSetObject(OCI_Elem *elem, OCI_Object *value)
Assign an Object handle to a collection element.
OCI_EXPORT unsigned int OCI_API OCI_GetUnsignedInt(OCI_Resultset *rs, unsigned int index)
Return the current unsigned integer value of the column at the given index in the resultset...
OCI_EXPORT boolean OCI_API OCI_RefIsNull(OCI_Ref *ref)
Check if the Ref points to an object or not.
unsigned int GetBusyConnectionsCount() const
Return the current number of busy connections/sessions.
OCI_EXPORT unsigned int OCI_API OCI_GetOCIRuntimeVersion(void)
Return the version of OCI used at runtime.
OCI_EXPORT boolean OCI_API OCI_BindFloat(OCI_Statement *stmt, const otext *name, float *data)
Bind a float variable.
OCI_EXPORT boolean OCI_API OCI_IsNull2(OCI_Resultset *rs, const otext *name)
Check if the current row value is null for the column of the given name in the resultset.
void SetPrefetchSize(unsigned int value)
Set the number of rows pre-fetched by OCI Client.
OCI_EXPORT boolean OCI_API OCI_TimestampGetDate(OCI_Timestamp *tmsp, int *year, int *month, int *day)
Extract the date part from a timestamp handle.
POCI_THREAD ThreadProc
Thread callback.
Definition: ocilib.hpp:1266
bool IsDataNull(unsigned int index=1) const
Check if the current bind value(s) used in SQL statements is marked as NULL.
Date & operator-=(int value)
Decrement the date by the given number of days.
OCI_EXPORT boolean OCI_API OCI_DequeueSetMode(OCI_Dequeue *dequeue, unsigned int mode)
Set the dequeuing/locking behavior.
Resultset GetNextResultset()
Retrieve the next available resultset.
ShutdownFlagsValues
Oracle instance shutdown flags enumerated values.
Definition: ocilib.hpp:851
OCI_EXPORT big_uint OCI_API OCI_LobGetMaxSize(OCI_Lob *lob)
Return the maximum size that the lob can contain.
OCI_EXPORT int OCI_API OCI_ElemGetInt(OCI_Elem *elem)
Return the int value of the given collection element.
unsigned int GetDefaultLobPrefetchSize() const
Return the default LOB prefetch buffer size for the connection.
OCI_EXPORT boolean OCI_API OCI_FileClose(OCI_File *file)
Close a file.
OCI_EXPORT boolean OCI_API OCI_DirPathPrepare(OCI_DirPath *dp)
Prepares the OCI direct path load interface before any rows can be converted or loaded.
OCI_EXPORT void *OCI_API OCI_LongGetBuffer(OCI_Long *lg)
Return the internal buffer of an OCI_Long object read from a fetch sequence.
OCI_EXPORT unsigned int OCI_API OCI_TypeInfoGetType(OCI_TypeInfo *typinf)
Return the type of the type info object.
void Watch(const ostring &sql)
Add a SQL query to monitor.
Statement GetStatement() const
Return the statement within the error occurred.
ostring GetServerVersion() const
Return the connected database server string version.
OCI_EXPORT boolean OCI_API OCI_SetFetchSize(OCI_Statement *stmt, unsigned int size)
Set the number of rows fetched per internal server fetch call.
ostring GetInstance() const
Return the Oracle server Instance name of the connected database/service name.
int GetFractionalPrecision() const
Return the fractional precision of the column for Timestamp and Interval columns. ...
OCI_EXPORT unsigned int OCI_API OCI_DirPathGetMaxRows(OCI_DirPath *dp)
Return the maximum number of rows allocated in the OCI and OCILIB internal arrays of rows...
OCI_EXPORT unsigned int OCI_API OCI_EnqueueGetSequenceDeviation(OCI_Enqueue *enqueue)
Return the sequence deviation of messages to enqueue to the queue.
Number(bool create=false)
Create an empty null number object.
void EnableServerOutput(unsigned int bufsize, unsigned int arrsize, unsigned int lnsize)
Enable the server output.
OCI_EXPORT OCI_Msg *OCI_API OCI_DequeueGet(OCI_Dequeue *dequeue)
Dequeue messages from the given queue.
OCI_EXPORT OCI_Agent *OCI_API OCI_AgentCreate(OCI_Connection *con, const otext *name, const otext *address)
Create an AQ agent object.
OCI_EXPORT unsigned int OCI_API OCI_GetBindMode(OCI_Statement *stmt)
Return the binding mode of a SQL statement.
OCI_EXPORT big_int OCI_API OCI_ObjectGetBigInt(OCI_Object *obj, const otext *attr)
Return the big integer value of the given object attribute.
OCI_EXPORT boolean OCI_API OCI_TimestampSysTimestamp(OCI_Timestamp *tmsp)
Stores the system current date and time as a timestamp value with time zone into the timestamp handle...
bool Seek(SeekMode seekMode, big_uint offset)
Move the current position within the file for read/write operations.
void Abort()
Terminate a direct path operation without committing changes.
OCI_EXPORT unsigned int OCI_API OCI_CollGetType(OCI_Coll *coll)
Return the collection type.
Date & operator+=(int value)
Increment the date by the given number of days.
OCI_EXPORT boolean OCI_API OCI_CollToText(OCI_Coll *coll, unsigned int *size, otext *str)
Convert a collection handle value to a string.
OCI_EXPORT boolean OCI_API OCI_SetSessionTag(OCI_Connection *con, const otext *tag)
Associate a tag to the given connection/session.
OCI_EXPORT boolean OCI_API OCI_BindIsNullAtPos(OCI_Bind *bnd, unsigned int position)
Check if the current entry value at the given index of the binded array is marked as NULL...
OCI_EXPORT boolean OCI_API OCI_MsgSetExpiration(OCI_Msg *msg, int value)
set the duration that the message is available for dequeuing
OCI_EXPORT unsigned int OCI_API OCI_TimestampGetType(OCI_Timestamp *tmsp)
Return the type of the given Timestamp object.
OCI_EXPORT boolean OCI_API OCI_IntervalFromText(OCI_Interval *itv, const otext *str)
Convert a string to an interval and store it in the given interval handle.
void SetSender(const Agent &agent)
Set the original sender of the message.
void SetTime(int hour, int min, int sec, int fsec)
Set the time part.
ostring MakeString(const otext *result, int size=-1)
Internal usage. Constructs a C++ string object from the given OCILIB string pointer.
Lob< ostring, LobNationalCharacter > NClob
Class handling NCLOB oracle type.
Definition: ocilib.hpp:4313
bool IsElementNull(unsigned int index) const
check if the element at the given index is null
ostring GetCorrelation() const
Get the correlation identifier of the message to be dequeued.
OCI_EXPORT OCI_Timestamp *OCI_API OCI_TimestampCreate(OCI_Connection *con, unsigned int type)
Create a local Timestamp instance.
OCI_EXPORT boolean OCI_API OCI_ObjectSetInterval(OCI_Object *obj, const otext *attr, OCI_Interval *value)
Set an object attribute of type Interval.
static void Acquire(MutexHandle handle)
Acquire a mutex lock.
OCI_EXPORT boolean OCI_API OCI_SetStatementCacheSize(OCI_Connection *con, unsigned int value)
Set the maximum number of statements to keep in the statement cache.
OCI_EXPORT boolean OCI_API OCI_ObjectSetBoolean(OCI_Object *obj, const otext *attr, boolean value)
Set an object attribute of type boolean (ONLY for PL/SQL records)
void SetReferenceNull()
Nullify the given Ref handle.
static big_uint GetAllocatedBytes(AllocatedBytesFlags type)
Return the current number of bytes allocated internally in the library.
OCI_EXPORT OCI_Thread *OCI_API OCI_ThreadCreate(void)
Create a Thread object.
void SetParallel(bool value)
Set the parallel loading mode.
OCI_EXPORT boolean OCI_API OCI_SetFormat(OCI_Connection *con, unsigned int type, const otext *format)
Set the format string for implicit string conversions of the given type.
ostring GetSQLVerb() const
Return the verb of the SQL command held by the statement.
OCI_EXPORT unsigned int OCI_API OCI_TypeInfoGetColumnCount(OCI_TypeInfo *typinf)
Return the number of columns of a table/view/object.
void SetAttributeNull(const ostring &name)
Set the given object attribute to null.
OCI_EXPORT boolean OCI_API OCI_ObjectSetFloat(OCI_Object *obj, const otext *attr, float value)
Set an object attribute of type float.
OCI_EXPORT OCI_Coll *OCI_API OCI_ObjectGetColl(OCI_Object *obj, const otext *attr)
Return the collection value of the given object attribute.
OCI_EXPORT boolean OCI_API OCI_SetLongMode(OCI_Statement *stmt, unsigned int mode)
Set the long data type handling mode of a SQL statement.
ostring GetService() const
Return the Oracle server Service name of the connected database/service name.
OCI_EXPORT boolean OCI_API OCI_AgentFree(OCI_Agent *agent)
Free an AQ agent object.
OCI_EXPORT OCI_Long *OCI_API OCI_GetLong2(OCI_Resultset *rs, const otext *name)
Return the current Long value of the column from its name in the resultset.
OCI_EXPORT int OCI_API OCI_IntervalCheck(OCI_Interval *itv)
Check if the given interval is valid.
OCI_EXPORT OCI_Connection *OCI_API OCI_StatementGetConnection(OCI_Statement *stmt)
Return the connection handle associated with a statement handle.
OCI_EXPORT boolean OCI_API OCI_QueueTableDrop(OCI_Connection *con, const otext *queue_table, boolean force)
Drop the given queue table.
OCI_EXPORT OCI_Timestamp *OCI_API OCI_GetTimestamp(OCI_Resultset *rs, unsigned int index)
Return the current timestamp value of the column at the given index in the resultset.
OCI_EXPORT boolean OCI_API OCI_BindLong(OCI_Statement *stmt, const otext *name, OCI_Long *data, unsigned int size)
Bind a Long variable.
OCI_EXPORT unsigned int OCI_API OCI_GetBindCount(OCI_Statement *stmt)
Return the number of binds currently associated to a statement.
void SetName(const ostring &value)
Set the given AQ agent name.
OCI_EXPORT OCI_Agent *OCI_API OCI_DequeueListen(OCI_Dequeue *dequeue, int timeout)
Listen for messages that match any recipient of the associated Agent list.
OCI_EXPORT boolean OCI_API OCI_MsgSetPriority(OCI_Msg *msg, int value)
Set the priority of the message.
void SetElementNull(unsigned int index)
Nullify the element at the given index.
OCI_EXPORT int OCI_API OCI_MsgGetEnqueueDelay(OCI_Msg *msg)
Return the number of seconds that a message is delayed for dequeuing.
Object identifying the SQL data type LOB (CLOB, NCLOB and BLOB)
Definition: ocilib.hpp:4019
OCI_EXPORT OCI_TypeInfo *OCI_API OCI_ColumnGetTypeInfo(OCI_Column *col)
Return the type information object associated to the column.
void SetEnqueueDelay(int value)
set the number of seconds to delay the enqueued message
OCI_EXPORT unsigned int OCI_API OCI_PoolGetTimeout(OCI_Pool *pool)
Get the idle timeout for connections/sessions in the pool.
OCI_EXPORT boolean OCI_API OCI_RegisterTimestamp(OCI_Statement *stmt, const otext *name, unsigned int type)
Register a timestamp output bind placeholder.
OCI_EXPORT OCI_File *OCI_API OCI_ObjectGetFile(OCI_Object *obj, const otext *attr)
Return the file value of the given object attribute.
unsigned int Append(const T &content)
Append the given content to the lob.
ostring GetConnectionString() const
Return the name of the connected database/service name.
unsigned int GetServerMajorVersion() const
Return the major version number of the connected database server.
TypeInfo(const Connection &connection, const ostring &name, TypeInfoType type)
Parametrized constructor.
OCI_EXPORT OCI_Interval *OCI_API OCI_ObjectGetInterval(OCI_Object *obj, const otext *attr)
Return the interval value of the given object attribute.
void Open(OpenMode mode)
Open explicitly a Lob.
OCI_EXPORT boolean OCI_API OCI_IntervalFree(OCI_Interval *itv)
Free an OCI_Interval handle.
Internal usage. Allow resolving a native type used by C API from a C++ type in binding operations...
OCI_EXPORT boolean OCI_API OCI_DirPathSave(OCI_DirPath *dp)
Execute a data save-point (server side)
Object GetObject() const
Returns the object pointed by the reference.
OCI_EXPORT boolean OCI_API OCI_MsgSetEnqueueDelay(OCI_Msg *msg, int value)
set the number of seconds to delay the enqueued message
OCI_EXPORT boolean OCI_API OCI_DateGetDate(OCI_Date *date, int *year, int *month, int *day)
Extract the date part from a date handle.
void Execute(const ostring &sql)
Prepare and execute a SQL statement or PL/SQL block.
TypeInfo GetTypeInfo() const
Return the TypeInfo object describing the referenced object.
bool GetNoWait() const
Get the waiting mode used when no more connections/sessions are available from the pool...
OCI_EXPORT unsigned int OCI_API OCI_ColumnGetSize(OCI_Column *col)
Return the size of the column.
static Timestamp SysTimestamp(TimestampType type=NoTimeZone)
return the current system timestamp
static Environment::CharsetMode GetCharset()
Return the OCILIB charset type.
OCI_EXPORT boolean OCI_API OCI_TransactionStart(OCI_Transaction *trans)
Start global transaction.
int GetYear() const
Return the date year value.
Lob< ostring, LobCharacter > Clob
Class handling CLOB oracle type.
Definition: ocilib.hpp:4302
bool operator>(const Date &other) const
Indicates if the current date value is superior to the given date value.
void SetExpiration(int value)
set the duration that the message is available for dequeuing
void SetVisibility(EnqueueVisibility value)
Set whether the new message is enqueued as part of the current transaction.
OCI_EXPORT unsigned int OCI_API OCI_GetColumnIndex(OCI_Resultset *rs, const otext *name)
Return the index of the column in the result from its name.
bool IsValid() const
Check if the given timestamp is valid.
OCI_EXPORT boolean OCI_API OCI_BindColl(OCI_Statement *stmt, const otext *name, OCI_Coll *data)
Bind a Collection variable.
void SetSessionTag(const ostring &tag)
Associate a tag to the given connection/session.
OCI_EXPORT unsigned int OCI_API OCI_LongWrite(OCI_Long *lg, void *buffer, unsigned int len)
Write a buffer into a Long.
struct OCI_Coll OCI_Coll
Oracle Collections (VARRAYs and Nested Tables) representation.
Definition: ocilib.h:618
OCI_EXPORT boolean OCI_API OCI_QueueDrop(OCI_Connection *con, const otext *queue_name)
Drop the given queue.
void Set(const ostring &name, const T &value)
Set the given object attribute value.
OCI_EXPORT int OCI_API OCI_ColumnGetPrecision(OCI_Column *col)
Return the precision of the column for numeric columns.
OCI_EXPORT const otext *OCI_API OCI_GetServerName(OCI_Connection *con)
Return the Oracle server machine name of the connected database/service name.
OCI_EXPORT boolean OCI_API OCI_DequeueUnsubscribe(OCI_Dequeue *dequeue)
Unsubscribe for asynchronous messages notifications.
OCI_EXPORT boolean OCI_API OCI_TransactionStop(OCI_Transaction *trans)
Stop current global transaction.
OCI_EXPORT boolean OCI_API OCI_NumberFromText(OCI_Number *number, const otext *str, const otext *fmt)
Convert a string to a number and store it in the given number handle.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfNumbers(OCI_Statement *stmt, const otext *name, OCI_Number **data, unsigned int nbelem)
Bind an array of Number.
OCI_EXPORT unsigned int OCI_API OCI_DirPathGetCurrentRows(OCI_DirPath *dp)
Return the current number of rows used in the OCILIB internal arrays of rows.
OCI_EXPORT boolean OCI_API OCI_MsgSetCorrelation(OCI_Msg *msg, const otext *correlation)
set the correlation identifier of the message
PropertyFlagsValues
Column properties flags values.
Definition: ocilib.hpp:6783
OCI_EXPORT unsigned int OCI_API OCI_ErrorGetRow(OCI_Error *err)
Return the row index which caused an error during statement execution.
OCI_EXPORT boolean OCI_API OCI_ElemFree(OCI_Elem *elem)
Free a local collection element.
OCI_EXPORT const otext *OCI_API OCI_AgentGetName(OCI_Agent *agent)
Get the given AQ agent name.
OCI_EXPORT OCI_DirPath *OCI_API OCI_DirPathCreate(OCI_TypeInfo *typinf, const otext *partition, unsigned int nb_cols, unsigned int nb_rows)
Create a direct path object.
void Unregister()
Unregister a previously registered notification.
OCI_EXPORT boolean OCI_API OCI_LobSeek(OCI_Lob *lob, big_uint offset, unsigned int mode)
Perform a seek operation on the OCI_lob content buffer.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfObjects(OCI_Statement *stmt, const otext *name, OCI_Object **data, OCI_TypeInfo *typinf, unsigned int nbelem)
Bind an array of object handles.
void SetYear(int value)
Set the date year value.
struct OCI_Elem OCI_Elem
Oracle Collection item representation.
Definition: ocilib.h:628
Interval Clone() const
Clone the current instance to a new one performing deep copy.
OCI_EXPORT boolean OCI_API OCI_DirPathFlushRow(OCI_DirPath *dp)
Flushes a partially loaded row from server.
OCI_EXPORT boolean OCI_API OCI_ElemSetTimestamp(OCI_Elem *elem, OCI_Timestamp *value)
Assign a Timestamp handle to a collection element.
OCI_EXPORT boolean OCI_API OCI_Initialize(POCI_ERROR err_handler, const otext *lib_path, unsigned int mode)
Initialize the library.
OCI_EXPORT const otext *OCI_API OCI_GetSql(OCI_Statement *stmt)
Return the last SQL or PL/SQL statement prepared or executed by the statement.
OCI_EXPORT OCI_Number *OCI_API OCI_ObjectGetNumber(OCI_Object *obj, const otext *attr)
Return the number value of the given object attribute.
AQ message.
Definition: ocilib.hpp:7310
Timestamp operator+(int value) const
Return a new Timestamp holding the current Timestamp value incremented by the given number of days...
Database resultset.
Definition: ocilib.hpp:6412
OCI_EXPORT OCI_Coll *OCI_API OCI_GetColl2(OCI_Resultset *rs, const otext *name)
Return the current Collection value of the column from its name in the resultset. ...
DirectPath(const TypeInfo &typeInfo, unsigned int nbCols, unsigned int nbRows, const ostring &partition=OTEXT(""))
Constructor.
OCI_EXPORT boolean OCI_API OCI_ObjectSetString(OCI_Object *obj, const otext *attr, const otext *value)
Set an object attribute of type string.
Date & operator++()
Increment the date by 1 day.
OCI_EXPORT big_uint OCI_API OCI_ElemGetUnsignedBigInt(OCI_Elem *elem)
Return the unsigned big int value of the given collection element.
OCI_EXPORT unsigned int OCI_API OCI_PoolGetMin(OCI_Pool *pool)
Return the minimum number of connections/sessions that can be opened to the database.
bool PingServer() const
Performs a round trip call to the server to confirm that the connection to the server is still valid...
void SetDateFormat(const ostring &format)
Set the default date format string for input conversion.
bool IsReferenceNull() const
Check if the reference points to an object or not.
OCI_EXPORT int OCI_API OCI_MsgGetAttemptCount(OCI_Msg *msg)
Return the number of attempts that have been made to dequeue the message.
Timestamp GetInstanceStartTime() const
Return the date and time (Timestamp) server instance start of the.
static unsigned int GetRuntimeMinorVersion()
Return the minor version number of OCI used at runtime.
unsigned int GetSize() const
Return the size of the column.
std::basic_string< otext, std::char_traits< otext >, std::allocator< otext > > ostring
string class wrapping the OCILIB otext * type and OTEXT() macros ( see Character sets ) ...
Definition: ocilib.hpp:160
OCI_EXPORT boolean OCI_API OCI_ElemSetShort(OCI_Elem *elem, short value)
Set a short value to a collection element.
int GetWaitTime() const
Return the time that Get() waits for messages if no messages are currently available.
Date GetEnqueueTime() const
return the time the message was enqueued
bool operator!=(const Lob &other) const
Indicates if the current lob value is not equal the given lob value.
big_uint GetMaxSize() const
Returns the lob maximum possible size.
struct OCI_Object OCI_Object
Oracle Named types representation.
Definition: ocilib.h:608
OCI_EXPORT unsigned int OCI_API OCI_BindGetDataCount(OCI_Bind *bnd)
Return the number of elements of the bind handle.
OCI_EXPORT OCI_Mutex *OCI_API OCI_MutexCreate(void)
Create a Mutex object.
unsigned int GetTimeout() const
Get the idle timeout for connections/sessions in the pool.
OCI_EXPORT OCI_Long *OCI_API OCI_LongCreate(OCI_Statement *stmt, unsigned int type)
Create a local temporary Long instance.
OCI_EXPORT boolean OCI_API OCI_IntervalAssign(OCI_Interval *itv, OCI_Interval *itv_src)
Assign the value of a interval handle to another one.
StartModeValues
Oracle instance start modes enumerated values.
Definition: ocilib.hpp:775
OCI_EXPORT int OCI_API OCI_IntervalCompare(OCI_Interval *itv, OCI_Interval *itv2)
Compares two interval handles.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfBigInts(OCI_Statement *stmt, const otext *name, big_int *data, unsigned int nbelem)
Bind an array of big integers.
bool IsValid() const
Check if the given interval is valid.
OCI_EXPORT OCI_Timestamp *OCI_API OCI_ElemGetTimestamp(OCI_Elem *elem)
Return the Timestamp value of the given collection element.
static unsigned int GetRuntimeMajorVersion()
Return the major version number of OCI used at runtime.
int GetDay() const
Return the timestamp day value.
void SetSeconds(int value)
Set the interval seconds value.
bool GetAutoCommit() const
Indicates if auto commit is currently activated.
int GetAttemptCount() const
Return the number of attempts that have been made to dequeue the message.
bool Seek(SeekMode mode, int offset)
Custom Fetch of the resultset.
struct OCI_Column OCI_Column
Oracle SQL Column and Type member representation.
Definition: ocilib.h:474
Raw GetRelativeMsgID() const
Get the message identifier of the message to be dequeued.
unsigned int GetPrefetchSize() const
Return the number of rows pre-fetched by OCI Client.
OCI_EXPORT unsigned int OCI_API OCI_GetDefaultLobPrefetchSize(OCI_Connection *con)
Return the default LOB prefetch buffer size for the connection.
bool IsOpened() const
Check if the specified file is currently opened on the server by our object.
OCI_EXPORT boolean OCI_API OCI_LobFree(OCI_Lob *lob)
Free a local temporary lob.
OCI_EXPORT unsigned int OCI_API OCI_ColumnGetType(OCI_Column *col)
Return the type of the given column.
static bool SetFormat(FormatType formatType, const ostring &format)
Set the format string for implicit string conversions of the given type.
void AddMonths(int months)
Add or subtract months.
bool GetServerOutput(ostring &line) const
Retrieve one line of the server buffer.
ObjectType GetType() const
Return the type of the given object.
OCI_EXPORT OCI_Object *OCI_API OCI_GetObject(OCI_Resultset *rs, unsigned int index)
Return the current Object value of the column at the given index in the resultset.
OCI_EXPORT boolean OCI_API OCI_TimestampGetTimeZoneOffset(OCI_Timestamp *tmsp, int *hour, int *min)
Return the time zone (hour, minute) portion of a timestamp handle.
ostring ToString() const
return a string representation of the current object
int GetExpiration() const
Return the duration that the message is available for dequeuing.
OCI_EXPORT boolean OCI_API OCI_EnqueuePut(OCI_Enqueue *enqueue, OCI_Msg *msg)
Enqueue a message on the queue associated to the Enqueue object.
OCI_EXPORT boolean OCI_API OCI_TransactionResume(OCI_Transaction *trans)
Resume a stopped global transaction.
OCI_EXPORT unsigned int OCI_API OCI_GetSqlErrorPos(OCI_Statement *stmt)
Return the error position (in terms of characters) in the SQL statement where the error occurred in c...
DataType GetType() const
Return the type of the given column.
OCI_EXPORT boolean OCI_API OCI_QueueStop(OCI_Connection *con, const otext *queue_name, boolean enqueue, boolean dequeue, boolean wait)
Stop enqueuing or dequeuing or both on the given queue.
OCI_EXPORT boolean OCI_API OCI_LobAppendLob(OCI_Lob *lob, OCI_Lob *lob_src)
Append a source LOB at the end of a destination LOB.
EnqueueMode GetMode() const
Return the enqueuing mode of messages to enqueue.
void Close()
Close the file on the server.
OCI_EXPORT boolean OCI_API OCI_MsgSetExceptionQueue(OCI_Msg *msg, const otext *queue)
Set the name of the queue to which the message is moved to if it cannot be processed successfully...
OCI_EXPORT boolean OCI_API OCI_RegisterInterval(OCI_Statement *stmt, const otext *name, unsigned int type)
Register an interval output bind placeholder.
bool operator==(const File &other) const
Indicates if the current file value is equal the given file value.
struct OCI_Error OCI_Error
Encapsulates an Oracle or OCILIB exception.
Definition: ocilib.h:689
void SetMonth(int value)
Set the interval month value.
OCI_EXPORT boolean OCI_API OCI_Parse(OCI_Statement *stmt, const otext *sql)
Parse a SQL statement or PL/SQL block.
OCI_EXPORT boolean OCI_API OCI_IntervalSetYearMonth(OCI_Interval *itv, int year, int month)
Set the year / month portion if the given Interval handle.
unsigned int GetSQLCommand() const
Return the Oracle SQL code the command held by the statement.
OCI_EXPORT OCI_Statement *OCI_API OCI_ErrorGetStatement(OCI_Error *err)
Retrieve statement handle within the error occurred.
void SetNavigation(NavigationMode value)
Set the position of messages to be retrieved.
OCI_EXPORT boolean OCI_API OCI_SetFetchMode(OCI_Statement *stmt, unsigned int mode)
Set the fetch mode of a SQL statement.
void SetRelativeMsgID(const Raw &value)
Set a message identifier to use for enqueuing messages using a sequence deviation.
OCI_EXPORT OCI_Number *OCI_API OCI_GetNumber2(OCI_Resultset *rs, const otext *name)
Return the current number value of the column from its name in the resultset.
OCI_EXPORT boolean OCI_API OCI_BindArrayOfColls(OCI_Statement *stmt, const otext *name, OCI_Coll **data, OCI_TypeInfo *typinf, unsigned int nbelem)
Bind an array of Collection handles.
Dequeue object for dequeuing messages into an Oracle Queue.
Definition: ocilib.hpp:7826
OCI_EXPORT boolean OCI_API OCI_DirPathSetDateFormat(OCI_DirPath *dp, const otext *format)
Set the default date format string for input conversion.
void Bind(const ostring &name, T &value, BindInfo::BindDirection mode)
Bind an host variable.
unsigned int GetTimeout() const
Return the transaction Timeout.
void Truncate(big_uint length)
Truncate the lob to a shorter length.
Transaction(const Connection &connection, unsigned int timeout, TransactionFlags flags, OCI_XID *pxid=nullptr)
Create a new global transaction or a serializable/read-only local transaction.
OCI_EXPORT boolean OCI_API OCI_DequeueSetRelativeMsgID(OCI_Dequeue *dequeue, const void *id, unsigned int len)
Set the message identifier of the message to be dequeued.
OCI_EXPORT boolean OCI_API OCI_RegisterRaw(OCI_Statement *stmt, const otext *name, unsigned int len)
Register an raw output bind placeholder.
OCI_EXPORT boolean OCI_API OCI_DirPathFinish(OCI_DirPath *dp)
Terminate a direct path operation and commit changes into the database.
OCI_EXPORT boolean OCI_API OCI_EnqueueFree(OCI_Enqueue *enqueue)
Free a Enqueue object.
bool First()
Fetch the first row of the resultset.
void SetYearMonth(int year, int month)
Set the Year / Month parts.
OCI_EXPORT boolean OCI_API OCI_RefAssign(OCI_Ref *ref, OCI_Ref *ref_src)
Assign a Ref to another one.
OCI_EXPORT const otext *OCI_API OCI_GetTrace(OCI_Connection *con, unsigned int trace)
Get the current trace for the trace type from the given connection.
bool Seek(SeekMode seekMode, big_uint offset)
Move the current position within the lob for read/write operations.
OCI_EXPORT OCI_Msg *OCI_API OCI_MsgCreate(OCI_TypeInfo *typinf)
Create a message object based on the given payload type.
void GetTimeZoneOffset(int &hour, int &min) const
Return the time zone (hour, minute) offsets.
OCI_EXPORT boolean OCI_API OCI_AgentSetAddress(OCI_Agent *agent, const otext *address)
Set the given AQ agent address.
void Truncate(unsigned int size)
Trim the given number of elements from the end of the collection.
static ThreadId GetThreadId(ThreadHandle handle)
Return the system Thread ID of the given thread handle.
bool operator==(const Interval &other) const
Indicates if the current Interval value is equal to the given Interval value.
OCI_EXPORT boolean OCI_API OCI_LobFlush(OCI_Lob *lob)
Flush Lob content to the server.
static void Create(const ostring &name, ThreadKeyFreeProc freeProc=nullptr)
Create a thread key object.
void EnableBuffering(bool value)
Enable / disable buffering mode on the given lob object.
bool operator-=(int offset)
Convenient operator overloading that performs a call to Seek() with Resultset::SeekRelative and the g...
int GetHours() const
Return the timestamp hours value.
T Get(const ostring &name) const
Return the given object attribute value.
EnvironmentFlagsValues
Environment Flags enumerated values.
Definition: ocilib.hpp:681
OCI_EXPORT OCI_Lob *OCI_API OCI_GetLob(OCI_Resultset *rs, unsigned int index)
Return the current lob value of the column at the given index in the resultset.
struct OCI_Event OCI_Event
OCILIB encapsulation of Oracle DCN event.
Definition: ocilib.h:739
void FlushRow()
Flushes a partially loaded row from server.
OCI_EXPORT boolean OCI_API OCI_BindUnsignedShort(OCI_Statement *stmt, const otext *name, unsigned short *data)
Bind an unsigned short variable.
OCI_EXPORT OCI_Subscription *OCI_API OCI_SubscriptionRegister(OCI_Connection *con, const otext *name, unsigned int type, POCI_NOTIFY handler, unsigned int port, unsigned int timeout)
Register a notification against the given database.
OCI_EXPORT OCI_Ref *OCI_API OCI_ElemGetRef(OCI_Elem *elem)
Return the Ref value of the given collection element.
OCI_EXPORT boolean OCI_API OCI_RegisterFloat(OCI_Statement *stmt, const otext *name)
Register a float output bind placeholder.
OCI_EXPORT boolean OCI_API OCI_NumberMultiply(OCI_Number *number, unsigned int type, void *value)
Multiply the given number with the value of a native C numeric.
OCI_EXPORT boolean OCI_API OCI_ElemSetFloat(OCI_Elem *elem, float value)
Set a float value to a collection element.
Subscription to database or objects changes.
Definition: ocilib.hpp:6959
ostring GetDatabaseName() const
Return the name of the database that generated the event.
Raw GetOriginalID() const
Return the original ID of the message in the last queue that generated this message.
BindMode GetBindMode() const
Return the binding mode of a SQL statement.
OCI_EXPORT unsigned int OCI_API OCI_ObjectGetRawSize(OCI_Object *obj, const otext *attr)
Return the raw attribute value size of the given object attribute into the given buffer.
ostring GetDirectory() const
Return the file directory.
struct OCI_Lob OCI_Lob
Oracle Internal Large objects:
Definition: ocilib.h:497
LongMode GetLongMode() const
Return the long data type handling mode of a SQL statement.
OCI_EXPORT boolean OCI_API OCI_BindRef(OCI_Statement *stmt, const otext *name, OCI_Ref *data)
Bind a Ref variable.
OCI_EXPORT boolean OCI_API OCI_FileIsEqual(OCI_File *file, OCI_File *file2)
Compare two file handle for equality.
OCI_EXPORT boolean OCI_API OCI_Cleanup(void)
Clean up all resources allocated by the library.
void Save()
Execute a data save-point (server side)
big_uint Erase(big_uint offset, big_uint length)
Erase a portion of the lob at a given position.
FailoverResult(* TAFHandlerProc)(Connection &con, FailoverRequest failoverRequest, FailoverEvent failoverEvent)
User callback for TAF event notifications.
Definition: ocilib.hpp:1790
OCI_EXPORT unsigned int OCI_API OCI_BindGetType(OCI_Bind *bnd)
Return the OCILIB type of the given bind.
OCI_EXPORT OCI_Number *OCI_API OCI_NumberCreate(OCI_Connection *con)
Create a local number object.
static ThreadHandle Create()
Create a Thread.
Connection()
Default constructor.
OCI_EXPORT OCI_Pool *OCI_API OCI_PoolCreate(const otext *db, const otext *user, const otext *pwd, unsigned int type, unsigned int mode, unsigned int min_con, unsigned int max_con, unsigned int incr_con)
Create an Oracle pool of connections or sessions.
bool Exists() const
Check if the given file exists on server.
OCI_EXPORT boolean OCI_API OCI_BindNumber(OCI_Statement *stmt, const otext *name, OCI_Number *data)
Bind an Number variable.
OCI_EXPORT boolean OCI_API OCI_TimestampConvert(OCI_Timestamp *tmsp, OCI_Timestamp *tmsp_src)
Convert one timestamp value from one type to another.