mcs/class/System.Data.OracleClient/System.Data.OracleClient.Oci/OciLobLocator.cs

   1 //
   2 // OciLobLocator.cs
   3 //
   4 // Part of managed C#/.NET library System.Data.OracleClient.dll
   5 //
   6 // Part of the Mono class libraries at
   7 // mcs/class/System.Data.OracleClient/System.Data.OracleClient.Oci
   8 //
   9 // Assembly: System.Data.OracleClient.dll
  10 // Namespace: System.Data.OracleClient.Oci
  11 //
  12 // Author:
  13 //     Tim Coleman <tim@timcoleman.com>
  14 //
  15 // Copyright (C) Tim Coleman, 2003
  16 //
  17
  18 using System;
  19 using System.Data.OracleClient;
  20 using System.Runtime.InteropServices;
  21
  22 namespace System.Data.OracleClient.Oci {
  23         internal sealed class OciLobLocator : OciDescriptorHandle, IDisposable
  24         {
  25                 #region Fields
  26
  27                 bool disposed = false;
  28                 OciErrorHandle errorHandle;
  29                 OciServiceHandle service;
  30                 OciEnvironmentHandle environment;
  31                 OciDataType type;
  32
  33                 #endregion // Fields
  34
  35                 #region Constructors
  36
  37                 public OciLobLocator (OciHandle parent, IntPtr handle)
  38                         : base (OciHandleType.LobLocator, parent, handle)
  39                 {
  40                 }
  41
  42                 #endregion // Constructors
  43
  44                 #region Properties
  45
  46                 public OciErrorHandle ErrorHandle {
  47                         get { return errorHandle; }
  48                         set { errorHandle = value; }
  49                 }
  50
  51                 public OciServiceHandle Service {
  52                         get { return service; }
  53                         set { service = value; }
  54                 }
  55
  56                 public OciDataType LobType {
  57                         get { return type; }
  58                         set { type = value; }
  59                 }
  60
  61                 public OciEnvironmentHandle Environment {
  62                         get { return environment; }
  63                         set { environment = value; }
  64                 }
  65
  66                 #endregion // Properties
  67
  68                 #region Methods
  69
  70                 public void BeginBatch (OracleLobOpenMode mode)
  71                 {
  72                         int status = 0;
  73                         status = OciCalls.OCILobOpen (Service,
  74                                                 ErrorHandle,
  75                                                 Handle,
  76                                                 (byte) mode);
  77
  78                         if (status != 0) {
  79                                 OciErrorInfo info = ErrorHandle.HandleError ();
  80                                 throw new OracleException (info.ErrorCode, info.ErrorMessage);
  81                         }
  82                 }
  83
  84                 public uint Copy (OciLobLocator destination, uint amount, uint destinationOffset, uint sourceOffset)
  85                 {
  86                         OciCalls.OCILobCopy (Service,
  87                                         ErrorHandle,
  88                                         destination,
  89                                         Handle,
  90                                         amount,
  91                                         destinationOffset,
  92                                         sourceOffset);
  93                         return amount;
  94                 }
  95
  96                 protected override void Dispose (bool disposing)
  97                 {
  98                         if (!disposed) {
  99                                 disposed = true;
 100                                 base.Dispose ();
 101                         }
 102                 }
 103
 104                 public void EndBatch ()
 105                 {
 106                         int status = 0;
 107                         status = OciCalls.OCILobClose (Service, ErrorHandle, this);
 108
 109                         if (status != 0) {
 110                                 OciErrorInfo info = ErrorHandle.HandleError ();
 111                                 throw new OracleException (info.ErrorCode, info.ErrorMessage);
 112                         }
 113                 }
 114
 115                 public uint Erase (uint offset, uint amount)
 116                 {
 117                         int status = 0;
 118                         uint output = amount;
 119                         status = OciCalls.OCILobErase (Service,
 120                                                 ErrorHandle,
 121                                                 this,
 122                                                 ref output,
 123                                                 (uint) offset);
 124
 125                         if (status != 0) {
 126                                 OciErrorInfo info = ErrorHandle.HandleError ();
 127                                 throw new OracleException (info.ErrorCode, info.ErrorMessage);
 128                         }
 129
 130                         return output;
 131                 }
 132
 133                 public int GetChunkSize ()
 134                 {
 135                         int status = 0;
 136                         uint output;
 137                         status = OciCalls.OCILobGetChunkSize (Service,
 138                                                         ErrorHandle,
 139                                                         this,
 140                                                         out output);
 141
 142                         if (status != 0) {
 143                                 OciErrorInfo info = ErrorHandle.HandleError ();
 144                                 throw new OracleException (info.ErrorCode, info.ErrorMessage);
 145                         }
 146
 147                         return (int) output;
 148                 }
 149
 150                 public long GetLength (bool binary)
 151                 {
 152                         int status = 0;
 153                         uint output;
 154                         status = OciCalls.OCILobGetLength (Service,
 155                                                 ErrorHandle,
 156                                                 this,
 157                                                 out output);
 158                         if (status != 0) {
 159                                 OciErrorInfo info = ErrorHandle.HandleError ();
 160                                 throw new OracleException (info.ErrorCode, info.ErrorMessage);
 161                         }
 162
 163                         if (!binary)
 164                                 output *= 2;
 165
 166                         return (long) output;
 167                 }
 168
 169                 public int Read (byte[] buffer, uint offset, uint count, bool binary)
 170                 {
 171                         int status = 0;
 172                         uint amount = count;
 173                         byte csfrm = 0;
 174
 175                         // Character types are UTF-16, so amount of characters is 1/2
 176                         // the amount of bytes
 177                         if (!binary) {
 178                                 amount /= 2;
 179                                 status = OciCalls.OCILobCharSetForm (environment,
 180                                              ErrorHandle,
 181                                              this,
 182                                              out csfrm);
 183                                 if (status != 0) {
 184                                         OciErrorInfo info = ErrorHandle.HandleError ();
 185                                         throw new OracleException (info.ErrorCode, info.ErrorMessage);
 186                                 }
 187                         }
 188
 189                         status = OciCalls.OCILobRead (Service,
 190                                                 ErrorHandle,
 191                                                 this,
 192                                                 ref amount,
 193                                                 offset,
 194                                                 buffer,
 195                                                 count,
 196                                                 IntPtr.Zero,
 197                                                 IntPtr.Zero,
 198                                                 1000,  // OCI_UCS2ID
 199                                                 csfrm);
 200
 201                         if (status != 0) {
 202                                 OciErrorInfo info = ErrorHandle.HandleError ();
 203                                 throw new OracleException (info.ErrorCode, info.ErrorMessage);
 204                         }
 205
 206                         return (int) amount;
 207                 }
 208
 209                 public void Trim (uint newlen)
 210                 {
 211                         int status = 0;
 212                         status = OciCalls.OCILobTrim (Service,
 213                                                 ErrorHandle,
 214                                                 this,
 215                                                 newlen);
 216
 217                         if (status != 0) {
 218                                 OciErrorInfo info = ErrorHandle.HandleError ();
 219                                 throw new OracleException (info.ErrorCode, info.ErrorMessage);
 220                         }
 221
 222                 }
 223
 224                 public int Write (byte[] buffer, uint offset, uint count, OracleType type)
 225                 {
 226                         int status = 0;
 227                         uint amount = count;
 228
 229                         if (type == OracleType.Clob)
 230                                 amount /= 2;
 231
 232                         status = OciCalls.OCILobWrite (Service,
 233                                                 ErrorHandle,
 234                                                 this,
 235                                                 ref amount,
 236                                                 offset,
 237                                                 buffer,
 238                                                 count,
 239                                                 0,    // OCI_ONE_PIECE
 240                                                 IntPtr.Zero,
 241                                                 IntPtr.Zero,
 242                                                 1000, // OCI_UCS2ID
 243                                                 0);
 244
 245                         if (status != 0) {
 246                                 OciErrorInfo info = ErrorHandle.HandleError ();
 247                                 throw new OracleException (info.ErrorCode, info.ErrorMessage);
 248                         }
 249
 250                         return (int) amount;
 251                 }
 252
 253                 #endregion // Methods
 254         }
 255 }