class/Npgsql/Npgsql/NpgsqlCopySerializer.cs

   1 // Npgsql.NpgsqlCopySerializer.cs
   2 //
   3 // Author:
   4 //     Kalle Hallivuori <kato@iki.fi>
   5 //
   6 //    Copyright (C) 2007 The Npgsql Development Team
   7 //    npgsql-general@gborg.postgresql.org
   8 //    http://gborg.postgresql.org/project/npgsql/projdisplay.php
   9 //
  10 // Permission to use, copy, modify, and distribute this software and its
  11 // documentation for any purpose, without fee, and without a written
  12 // agreement is hereby granted, provided that the above copyright notice
  13 // and this paragraph and the following two paragraphs appear in all copies.
  14 //
  15 // IN NO EVENT SHALL THE NPGSQL DEVELOPMENT TEAM BE LIABLE TO ANY PARTY
  16 // FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES,
  17 // INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS
  18 // DOCUMENTATION, EVEN IF THE NPGSQL DEVELOPMENT TEAM HAS BEEN ADVISED OF
  19 // THE POSSIBILITY OF SUCH DAMAGE.
  20 //
  21 // THE NPGSQL DEVELOPMENT TEAM SPECIFICALLY DISCLAIMS ANY WARRANTIES,
  22 // INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
  23 // AND FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
  24 // ON AN "AS IS" BASIS, AND THE NPGSQL DEVELOPMENT TEAM HAS NO OBLIGATIONS
  25 // TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
  26
  27
  28 using System;
  29 using System.IO;
  30 using System.Text;
  31
  32 namespace Npgsql
  33 {
  34         /// <summary>
  35         /// Writes given objects into a stream for PostgreSQL COPY in default copy format (not CSV or BINARY).
  36         /// </summary>
  37         public class NpgsqlCopySerializer
  38         {
  39                 private static readonly Encoding ENCODING_UTF8 = Encoding.UTF8;
  40
  41                 public static String DEFAULT_DELIMITER = "\t",
  42                                      DEFAULT_SEPARATOR = "\n",
  43                                      DEFAULT_NULL = "\\N",
  44                                      DEFAULT_ESCAPE = "\\",
  45                                      DEFAULT_QUOTE = "\"";
  46
  47                 public static int DEFAULT_BUFFER_SIZE = 8192;
  48
  49                 private readonly NpgsqlConnector _context;
  50                 private Stream _toStream;
  51
  52                 private String _delimiter = DEFAULT_DELIMITER,
  53                                _escape = DEFAULT_ESCAPE,
  54                                _separator = DEFAULT_SEPARATOR,
  55                                _null = DEFAULT_NULL;
  56
  57                 private byte[] _delimiterBytes = null, _escapeBytes = null, _separatorBytes = null, _nullBytes = null;
  58                 private byte[][] _escapeSequenceBytes = null;
  59                 private String[] _stringsToEscape = null;
  60
  61                 private byte[] _sendBuffer = null;
  62                 private int _sendBufferAt = 0, _lastFieldEndAt = 0, _lastRowEndAt = 0, _atField = 0;
  63
  64                 public NpgsqlCopySerializer(NpgsqlConnection conn)
  65                 {
  66                         _context = conn.Connector;
  67                 }
  68
  69                 public bool IsActive
  70                 {
  71                         get { return _toStream != null && _context.Mediator.CopyStream == _toStream && _context.CurrentState is NpgsqlCopyInState; }
  72                 }
  73
  74                 public Stream ToStream
  75                 {
  76                         get
  77                         {
  78                                 if (_toStream == null)
  79                                 {
  80                                         _toStream = _context.Mediator.CopyStream;
  81                                 }
  82                                 return _toStream;
  83                         }
  84                         set
  85                         {
  86                                 if (IsActive)
  87                                 {
  88                                         throw new NpgsqlException("Do not change stream of an active " + this);
  89                                 }
  90                                 _toStream = value;
  91                         }
  92                 }
  93
  94                 public String Delimiter
  95                 {
  96                         get { return _delimiter; }
  97                         set
  98                         {
  99                                 if (IsActive)
 100                                 {
 101                                         throw new NpgsqlException("Do not change delimiter of an active " + this);
 102                                 }
 103                                 _delimiter = value ?? DEFAULT_DELIMITER;
 104                                 _delimiterBytes = null;
 105                                 _stringsToEscape = null;
 106                                 _escapeSequenceBytes = null;
 107                         }
 108                 }
 109
 110                 private byte[] DelimiterBytes
 111                 {
 112                         get
 113                         {
 114                                 if (_delimiterBytes == null)
 115                                 {
 116                                         _delimiterBytes = ENCODING_UTF8.GetBytes(_delimiter);
 117                                 }
 118                                 return _delimiterBytes;
 119                         }
 120                 }
 121
 122                 public String Separator
 123                 {
 124                         get { return _separator; }
 125                         set
 126                         {
 127                                 if (IsActive)
 128                                 {
 129                                         throw new NpgsqlException("Do not change separator of an active " + this);
 130                                 }
 131                                 _separator = value ?? DEFAULT_SEPARATOR;
 132                                 _separatorBytes = null;
 133                                 _stringsToEscape = null;
 134                                 _escapeSequenceBytes = null;
 135                         }
 136                 }
 137
 138                 private byte[] SeparatorBytes
 139                 {
 140                         get
 141                         {
 142                                 if (_separatorBytes == null)
 143                                 {
 144                                         _separatorBytes = ENCODING_UTF8.GetBytes(_separator);
 145                                 }
 146                                 return _separatorBytes;
 147                         }
 148                 }
 149
 150                 public String Escape
 151                 {
 152                         get { return _escape; }
 153                         set
 154                         {
 155                                 if (IsActive)
 156                                 {
 157                                         throw new NpgsqlException("Do not change escape symbol of an active " + this);
 158                                 }
 159                                 _escape = value ?? DEFAULT_ESCAPE;
 160                                 _escapeBytes = null;
 161                                 _stringsToEscape = null;
 162                                 _escapeSequenceBytes = null;
 163                         }
 164                 }
 165
 166                 private byte[] EscapeBytes
 167                 {
 168                         get
 169                         {
 170                                 if (_escapeBytes == null)
 171                                 {
 172                                         _escapeBytes = ENCODING_UTF8.GetBytes(_escape);
 173                                 }
 174                                 return _escapeBytes;
 175                         }
 176                 }
 177
 178                 public String Null
 179                 {
 180                         get { return _null; }
 181                         set
 182                         {
 183                                 if (IsActive)
 184                                 {
 185                                         throw new NpgsqlException("Do not change null symbol of an active " + this);
 186                                 }
 187                                 _null = value ?? DEFAULT_NULL;
 188                                 _nullBytes = null;
 189                                 _stringsToEscape = null;
 190                                 _escapeSequenceBytes = null;
 191                         }
 192                 }
 193
 194                 private byte[] NullBytes
 195                 {
 196                         get
 197                         {
 198                                 if (_nullBytes == null)
 199                                 {
 200                                         _nullBytes = ENCODING_UTF8.GetBytes(_null);
 201                                 }
 202                                 return _nullBytes;
 203                         }
 204                 }
 205
 206                 public Int32 BufferSize
 207                 {
 208                         get { return _sendBuffer != null ? _sendBuffer.Length : DEFAULT_BUFFER_SIZE; }
 209                         set
 210                         {
 211                                 byte[] _newBuffer = new byte[value];
 212                                 if (_sendBuffer != null)
 213                                 {
 214                                         for (int i = 0; i < _sendBufferAt; i++)
 215                                         {
 216                                                 _newBuffer[i] = _sendBuffer[i];
 217                                         }
 218                                 }
 219                                 _sendBuffer = _newBuffer;
 220                         }
 221                 }
 222
 223                 public void Flush()
 224                 {
 225                         if (_sendBufferAt > 0)
 226                         {
 227                                 ToStream.Write(_sendBuffer, 0, _sendBufferAt);
 228                                 ToStream.Flush();
 229                         }
 230                         _sendBufferAt = 0;
 231                         _lastRowEndAt = 0;
 232                         _lastFieldEndAt = 0;
 233                 }
 234
 235                 public void FlushRows()
 236                 {
 237                         if (_lastRowEndAt > 0)
 238                         {
 239                                 ToStream.Write(_sendBuffer, 0, _lastRowEndAt);
 240                                 ToStream.Flush();
 241                                 int len = _sendBufferAt - _lastRowEndAt;
 242                                 for (int i = 0; i < len; i++)
 243                                 {
 244                                         _sendBuffer[i] = _sendBuffer[_lastRowEndAt + i];
 245                                 }
 246                                 _lastFieldEndAt -= _lastRowEndAt;
 247                                 _sendBufferAt -= _lastRowEndAt;
 248                                 _lastRowEndAt = 0;
 249                         }
 250                 }
 251
 252                 public void FlushFields()
 253                 {
 254                         if (_lastFieldEndAt > 0)
 255                         {
 256                                 ToStream.Write(_sendBuffer, 0, _lastFieldEndAt);
 257                                 ToStream.Flush();
 258                                 int len = _sendBufferAt - _lastFieldEndAt;
 259                                 for (int i = 0; i < len; i++)
 260                                 {
 261                                         _sendBuffer[i] = _sendBuffer[_lastFieldEndAt + i];
 262                                 }
 263                                 _lastRowEndAt -= _lastFieldEndAt;
 264                                 _sendBufferAt -= _lastFieldEndAt;
 265                                 _lastFieldEndAt = 0;
 266                         }
 267                 }
 268
 269                 public void Close()
 270                 {
 271                         if (_atField > 0)
 272                         {
 273                                 EndRow();
 274                         }
 275                         Flush();
 276                         ToStream.Close();
 277                 }
 278
 279                 protected int SpaceInBuffer
 280                 {
 281                         get { return BufferSize - _sendBufferAt; }
 282                 }
 283
 284                 protected String[] StringsToEscape
 285                 {
 286                         get
 287                         {
 288                                 if (_stringsToEscape == null)
 289                                 {
 290                                         _stringsToEscape = new String[] {Delimiter, Separator, Escape, "\r", "\n"};
 291                                 }
 292                                 return _stringsToEscape;
 293                         }
 294                 }
 295
 296                 protected byte[][] EscapeSequenceBytes
 297                 {
 298                         get
 299                         {
 300                                 if (_escapeSequenceBytes == null)
 301                                 {
 302                                         _escapeSequenceBytes = new byte[StringsToEscape.Length][];
 303                                         for (int i = 0; i < StringsToEscape.Length; i++)
 304                                         {
 305                                                 _escapeSequenceBytes[i] = EscapeSequenceFor(StringsToEscape[i].ToCharArray(0, 1)[0]);
 306                                         }
 307                                 }
 308                                 return _escapeSequenceBytes;
 309                         }
 310                 }
 311
 312                 private static readonly byte[] esc_t = new byte[] {(byte) 't'};
 313
 314                 private static readonly byte[] esc_n = new byte[] {(byte) 'n'};
 315
 316                 private static readonly byte[] esc_r = new byte[] {(byte) 'r'};
 317
 318                 private static readonly byte[] esc_b = new byte[] {(byte) 'b'};
 319
 320                 private static readonly byte[] esc_f = new byte[] {(byte) 'f'};
 321
 322                 private static readonly byte[] esc_v = new byte[] {(byte) 'v'};
 323
 324                 protected static byte[] EscapeSequenceFor(char c)
 325                 {
 326                         return
 327                                 c == '\t'
 328                                         ? esc_t
 329                                         : c == '\n'
 330                                                 ? esc_n
 331                                                 : c == '\r'
 332                                                         ? esc_r
 333                                                         : c == '\b'
 334                                                                 ? esc_b
 335                                                                 : c == '\f'
 336                                                                         ? esc_f
 337                                                                         : c == '\v'
 338                                                                                 ? esc_v
 339                                                                                 : (c < 32 || c > 127)
 340                                                                                         ? new byte[] {(byte) ('0' + ((c/64) & 7)), (byte) ('0' + ((c/8) & 7)), (byte) ('0' + (c & 7))}
 341                                                                                         : new byte[] {(byte) c};
 342                 }
 343
 344                 protected void MakeRoomForBytes(int len)
 345                 {
 346                         if (_sendBuffer == null)
 347                         {
 348                                 _sendBuffer = new byte[BufferSize];
 349                         }
 350                         if (len >= SpaceInBuffer)
 351                         {
 352                                 FlushRows();
 353                                 if (len >= SpaceInBuffer)
 354                                 {
 355                                         FlushFields();
 356                                         if (len >= SpaceInBuffer)
 357                                         {
 358                                                 BufferSize = len;
 359                                         }
 360                                 }
 361                         }
 362                 }
 363
 364                 protected void AddBytes(byte[] bytes)
 365                 {
 366                         MakeRoomForBytes(bytes.Length);
 367
 368                         for (int i = 0; i < bytes.Length; i++)
 369                         {
 370                                 _sendBuffer[_sendBufferAt++] = bytes[i];
 371                         }
 372                 }
 373
 374                 public void EndRow()
 375                 {
 376                         if (_context != null)
 377                         {
 378                                 while (_atField < _context.CurrentState.CopyFormat.FieldCount)
 379                                 {
 380                                         AddNull();
 381                                 }
 382                         }
 383                         if (_context == null || ! _context.CurrentState.CopyFormat.IsBinary)
 384                         {
 385                                 AddBytes(SeparatorBytes);
 386                         }
 387                         _lastRowEndAt = _sendBufferAt;
 388                         _atField = 0;
 389                 }
 390
 391                 protected void PrefixField()
 392                 {
 393                         if (_atField > 0)
 394                         {
 395                                 if (_atField >= _context.CurrentState.CopyFormat.FieldCount)
 396                                 {
 397                                         throw new NpgsqlException("Tried to add too many fields to a copy record with " + _atField + " fields");
 398                                 }
 399                                 AddBytes(DelimiterBytes);
 400                         }
 401                 }
 402
 403                 protected void FieldAdded()
 404                 {
 405                         _lastFieldEndAt = _sendBufferAt;
 406                         _atField++;
 407                 }
 408
 409                 public void AddNull()
 410                 {
 411                         PrefixField();
 412                         AddBytes(NullBytes);
 413                         FieldAdded();
 414                 }
 415
 416                 public void AddString(String fieldValue)
 417                 {
 418                         PrefixField();
 419                         int bufferedUpto = 0;
 420                         while (bufferedUpto < fieldValue.Length)
 421                         {
 422                                 int escapeAt = fieldValue.Length;
 423                                 byte[] escapeSequence = null;
 424
 425                                 // choose closest instance of strings to escape in fieldValue
 426                                 for (int eachEscapeable = 0; eachEscapeable < StringsToEscape.Length; eachEscapeable++)
 427                                 {
 428                                         int i = fieldValue.IndexOf(StringsToEscape[eachEscapeable], bufferedUpto);
 429                                         if (i > -1 && i < escapeAt)
 430                                         {
 431                                                 escapeAt = i;
 432                                                 escapeSequence = EscapeSequenceBytes[eachEscapeable];
 433                                         }
 434                                 }
 435
 436                                 // some, possibly all of fieldValue string does not require escaping and can be buffered for output
 437                                 if (escapeAt > bufferedUpto)
 438                                 {
 439                                         int encodedLength = ENCODING_UTF8.GetByteCount(fieldValue.ToCharArray(bufferedUpto, escapeAt));
 440                                         MakeRoomForBytes(encodedLength);
 441                                         _sendBufferAt += ENCODING_UTF8.GetBytes(fieldValue, bufferedUpto, escapeAt, _sendBuffer, _sendBufferAt);
 442                                         bufferedUpto = escapeAt;
 443                                 }
 444
 445                                 // now buffer the escape sequence for output
 446                                 if (escapeSequence != null)
 447                                 {
 448                                         AddBytes(EscapeBytes);
 449                                         AddBytes(escapeSequence);
 450                                         bufferedUpto++;
 451                                 }
 452                         }
 453                         FieldAdded();
 454                 }
 455
 456                 public void AddInt32(Int32 fieldValue)
 457                 {
 458                         AddString(string.Format("{0}", fieldValue));
 459                 }
 460
 461                 public void AddInt64(Int64 fieldValue)
 462                 {
 463                         AddString(string.Format("{0}", fieldValue));
 464                 }
 465
 466                 public void AddNumber(double fieldValue)
 467                 {
 468                         AddString(string.Format("{0}", fieldValue));
 469                 }
 470
 471                 public void AddBool(bool fieldValue)
 472                 {
 473                         AddString(fieldValue ? "TRUE" : "FALSE");
 474                 }
 475
 476                 public void AddDateTime(DateTime fieldValue)
 477                 {
 478                         AddString(string.Format("{0}-{1}-{2} {3}:{4}:{5}.{6}", fieldValue.Year, fieldValue.Month, fieldValue.Day, fieldValue.Hour, fieldValue.Minute, fieldValue.Second, fieldValue.Millisecond));
 479                 }
 480         }
 481 }