class/Npgsql/NpgsqlTypes/NpgsqlTypeConverters.cs

   1 // NpgsqlTypes.NpgsqlTypesHelper.cs
   2 //
   3 // Author:
   4 //      Glen Parker <glenebob@nwlink.com>
   5 //
   6 //      Copyright (C) 2004 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 // This file provides data type converters between PostgreSQL representations
  28 // and .NET objects.
  29
  30 using System;
  31 using System.Collections.Generic;
  32 using System.Globalization;
  33 using System.IO;
  34 using System.Net;
  35 using System.Text;
  36 using System.Text.RegularExpressions;
  37
  38 namespace NpgsqlTypes
  39 {
  40         /// <summary>
  41         /// Provide event handlers to convert all native supported basic data types from their backend
  42         /// text representation to a .NET object.
  43         /// </summary>
  44         internal abstract class BasicBackendToNativeTypeConverter
  45         {
  46                 private static readonly String[] DateFormats = new String[] { "yyyy-MM-dd", };
  47
  48                 private static readonly String[] TimeFormats =
  49                         new String[]
  50                                 {
  51                                         "HH:mm:ss.ffffff", "HH:mm:ss", "HH:mm:ss.ffffffzz", "HH:mm:sszz", "HH:mm:ss.fffff", "HH:mm:ss.ffff", "HH:mm:ss.fff"
  52                                         , "HH:mm:ss.ff", "HH:mm:ss.f", "HH:mm:ss.fffffzz", "HH:mm:ss.ffffzz", "HH:mm:ss.fffzz", "HH:mm:ss.ffzz",
  53                                         "HH:mm:ss.fzz",
  54                                 };
  55
  56                 private static readonly String[] DateTimeFormats =
  57                         new String[]
  58                                 {
  59                                         "yyyy-MM-dd HH:mm:ss.ffffff", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd HH:mm:ss.ffffffzz", "yyyy-MM-dd HH:mm:sszz",
  60                                         "yyyy-MM-dd HH:mm:ss.fffff", "yyyy-MM-dd HH:mm:ss.ffff", "yyyy-MM-dd HH:mm:ss.fff", "yyyy-MM-dd HH:mm:ss.ff",
  61                                         "yyyy-MM-dd HH:mm:ss.f", "yyyy-MM-dd HH:mm:ss.fffffzz", "yyyy-MM-dd HH:mm:ss.ffffzz", "yyyy-MM-dd HH:mm:ss.fffzz",
  62                                         "yyyy-MM-dd HH:mm:ss.ffzz", "yyyy-MM-dd HH:mm:ss.fzz",
  63                                 };
  64
  65                 /// <summary>
  66                 /// Binary data.
  67                 /// </summary>
  68                 internal static Object ToBinary(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
  69                 {
  70                         Int32 octalValue = 0;
  71                         Int32 byteAPosition = 0;
  72                         Int32 byteAStringLength = BackendData.Length;
  73                         MemoryStream ms = new MemoryStream();
  74
  75                         while (byteAPosition < byteAStringLength)
  76                         {
  77                                 // The IsDigit is necessary in case we receive a \ as the octal value and not
  78                                 // as the indicator of a following octal value in decimal format.
  79                                 // i.e.: \201\301P\A
  80                                 if (BackendData[byteAPosition] == '\\')
  81                                 {
  82                                         if (byteAPosition + 1 == byteAStringLength)
  83                                         {
  84                                                 octalValue = '\\';
  85                                                 byteAPosition++;
  86                                         }
  87                                         else if (Char.IsDigit(BackendData[byteAPosition + 1]))
  88                                         {
  89                         octalValue = Convert.ToByte(BackendData.Substring(byteAPosition + 1, 3), 8);
  90                         //octalValue = (Byte.Parse(BackendData[byteAPosition + 1].ToString()) << 6);
  91                         //octalValue |= (Byte.Parse(BackendData[byteAPosition + 2].ToString()) << 3);
  92                         //octalValue |= Byte.Parse(BackendData[byteAPosition + 3].ToString());
  93                                                 byteAPosition += 4;
  94                                         }
  95                                         else
  96                                         {
  97                                                 octalValue = '\\';
  98                                                 byteAPosition += 2;
  99                                         }
 100                                 }
 101                                 else
 102                                 {
 103                                         octalValue = (Byte)BackendData[byteAPosition];
 104                                         byteAPosition++;
 105                                 }
 106
 107
 108                                 ms.WriteByte((Byte)octalValue);
 109                         }
 110
 111                         return ms.ToArray();
 112                 }
 113
 114                 /// <summary>
 115                 /// Convert a postgresql boolean to a System.Boolean.
 116                 /// </summary>
 117                 internal static Object ToBoolean(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize,
 118                                                                                  Int32 TypeModifier)
 119                 {
 120                         return (BackendData.ToLower() == "t" ? true : false);
 121                 }
 122
 123
 124                 /// <summary>
 125                 /// Convert a postgresql bit to a System.Boolean.
 126                 /// </summary>
 127                 internal static Object ToBit(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 128                 {
 129                         return (BackendData.ToLower() == "1" ? true : false);
 130                 }
 131
 132                 /// <summary>
 133                 /// Convert a postgresql datetime to a System.DateTime.
 134                 /// </summary>
 135                 internal static Object ToDateTime(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize,
 136                                                                                   Int32 TypeModifier)
 137                 {
 138                         // Get the date time parsed in all expected formats for timestamp.
 139
 140                         // First check for special values infinity and -infinity.
 141
 142                         if (BackendData == "infinity")
 143                         {
 144                                 return DateTime.MaxValue;
 145                         }
 146
 147                         if (BackendData == "-infinity")
 148                         {
 149                                 return DateTime.MinValue;
 150                         }
 151
 152                         return
 153                                 DateTime.ParseExact(BackendData, DateTimeFormats, DateTimeFormatInfo.InvariantInfo,
 154                                                                         DateTimeStyles.NoCurrentDateDefault | DateTimeStyles.AllowWhiteSpaces);
 155                 }
 156
 157                 /// <summary>
 158                 /// Convert a postgresql date to a System.DateTime.
 159                 /// </summary>
 160                 internal static Object ToDate(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 161                 {
 162                         return
 163                                 DateTime.ParseExact(BackendData, DateFormats, DateTimeFormatInfo.InvariantInfo, DateTimeStyles.AllowWhiteSpaces);
 164                 }
 165
 166                 /// <summary>
 167                 /// Convert a postgresql time to a System.DateTime.
 168                 /// </summary>
 169                 internal static Object ToTime(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 170                 {
 171                         return
 172                                 DateTime.ParseExact(BackendData, TimeFormats, DateTimeFormatInfo.InvariantInfo,
 173                                                                         DateTimeStyles.NoCurrentDateDefault | DateTimeStyles.AllowWhiteSpaces);
 174                 }
 175
 176                 /// <summary>
 177                 /// Convert a postgresql money to a System.Decimal.
 178                 /// </summary>
 179                 internal static Object ToMoney(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 180                 {
 181                         // It's a number with a $ on the beginning...
 182                         return Convert.ToDecimal(BackendData.Substring(1, BackendData.Length - 1), CultureInfo.InvariantCulture);
 183                 }
 184         }
 185
 186         /// <summary>
 187         /// Provide event handlers to convert the basic native supported data types from
 188         /// native form to backend representation.
 189         /// </summary>
 190         internal abstract class BasicNativeToBackendTypeConverter
 191         {
 192                 /// <summary>
 193                 /// Binary data.
 194                 /// </summary>
 195                 internal static String ToBinary(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 196                 {
 197                         Byte[] byteArray = (Byte[])NativeData;
 198                         int len = byteArray.Length;
 199                         char[] res = new char[len * 5];
 200
 201                         for (int i = 0, o = 0; i < len; ++i, o += 5)
 202                         {
 203                                 byte item = byteArray[i];
 204                                 res[o] = res[o + 1] = '\\';
 205                                 res[o + 2] = (char)('0' + (7 & (item >> 6)));
 206                                 res[o + 3] = (char)('0' + (7 & (item >> 3)));
 207                                 res[o + 4] = (char)('0' + (7 & item));
 208                         }
 209
 210                         return new String(res);
 211                 }
 212
 213                 /// <summary>
 214                 /// Convert to a postgresql boolean.
 215                 /// </summary>
 216                 internal static String ToBoolean(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 217                 {
 218                         return ((bool)NativeData) ? "TRUE" : "FALSE";
 219                 }
 220
 221                 /// <summary>
 222                 /// Convert to a postgresql bit.
 223                 /// </summary>
 224                 internal static String ToBit(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 225                 {
 226                         // Convert boolean values to bit or convert int32 values to bit - odd values are 1 and
 227                         // even numbers are 0.
 228                         if (NativeData is Boolean)
 229                         {
 230                                 return ((Boolean)NativeData) ? "1" : "0";
 231                         }
 232                         else
 233                         {
 234                                 return (((Int32)NativeData) % 2 == 1) ? "1" : "0";
 235                         }
 236                 }
 237
 238                 /// <summary>
 239                 /// Convert to a postgresql timestamp.
 240                 /// </summary>
 241                 internal static String ToDateTime(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 242                 {
 243                         if (!(NativeData is DateTime))
 244                         {
 245                                 return ExtendedNativeToBackendTypeConverter.ToTimeStamp(TypeInfo, NativeData);
 246                         }
 247                         if (DateTime.MaxValue.Equals(NativeData))
 248                         {
 249                                 return "infinity";
 250                         }
 251                         if (DateTime.MinValue.Equals(NativeData))
 252                         {
 253                                 return "-infinity";
 254                         }
 255                         return ((DateTime)NativeData).ToString("yyyy-MM-dd HH:mm:ss.ffffff", DateTimeFormatInfo.InvariantInfo);
 256                 }
 257
 258                 /// <summary>
 259                 /// Convert to a postgresql date.
 260                 /// </summary>
 261                 internal static String ToDate(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 262                 {
 263                         if (!(NativeData is DateTime))
 264                         {
 265                                 return ExtendedNativeToBackendTypeConverter.ToDate(TypeInfo, NativeData);
 266                         }
 267                         return ((DateTime)NativeData).ToString("yyyy-MM-dd", DateTimeFormatInfo.InvariantInfo);
 268                 }
 269
 270                 /// <summary>
 271                 /// Convert to a postgresql time.
 272                 /// </summary>
 273                 internal static String ToTime(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 274                 {
 275                         if (!(NativeData is DateTime))
 276                         {
 277                                 return ExtendedNativeToBackendTypeConverter.ToTime(TypeInfo, NativeData);
 278                         }
 279                         else
 280                         {
 281                                 return ((DateTime)NativeData).ToString("HH:mm:ss.ffffff", DateTimeFormatInfo.InvariantInfo);
 282                         }
 283                 }
 284
 285                 /// <summary>
 286                 /// Convert to a postgres money.
 287                 /// </summary>
 288                 internal static String ToMoney(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 289                 {
 290                         return "$" + ((IFormattable)NativeData).ToString(null, CultureInfo.InvariantCulture.NumberFormat);
 291                 }
 292         }
 293
 294
 295         /// <summary>
 296         /// Provide event handlers to convert extended native supported data types from their backend
 297         /// text representation to a .NET object.
 298         /// </summary>
 299         internal abstract class ExtendedBackendToNativeTypeConverter
 300         {
 301                 private static readonly Regex pointRegex = new Regex(@"\((-?\d+.?\d*),(-?\d+.?\d*)\)");
 302                 private static readonly Regex boxlsegRegex = new Regex(@"\((-?\d+.?\d*),(-?\d+.?\d*)\),\((-?\d+.?\d*),(-?\d+.?\d*)\)");
 303                 private static readonly Regex pathpolygonRegex = new Regex(@"\((-?\d+.?\d*),(-?\d+.?\d*)\)");
 304                 private static readonly Regex circleRegex = new Regex(@"<\((-?\d+.?\d*),(-?\d+.?\d*)\),(\d+.?\d*)>");
 305
 306
 307                 /// <summary>
 308                 /// Convert a postgresql point to a System.NpgsqlPoint.
 309                 /// </summary>
 310                 internal static Object ToPoint(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 311                 {
 312                         Match m = pointRegex.Match(BackendData);
 313
 314                         return
 315                                 new NpgsqlPoint(Single.Parse(m.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
 316                                                                 Single.Parse(m.Groups[2].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat));
 317                 }
 318
 319                 /// <summary>
 320                 /// Convert a postgresql point to a System.RectangleF.
 321                 /// </summary>
 322                 internal static Object ToBox(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 323                 {
 324                         Match m = boxlsegRegex.Match(BackendData);
 325
 326                         return
 327                                 new NpgsqlBox(
 328                                         new NpgsqlPoint(Single.Parse(m.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
 329                                                                         Single.Parse(m.Groups[2].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)),
 330                                         new NpgsqlPoint(Single.Parse(m.Groups[3].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
 331                                                                         Single.Parse(m.Groups[4].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)));
 332                 }
 333
 334                 /// <summary>
 335                 /// LDeg.
 336                 /// </summary>
 337                 internal static Object ToLSeg(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 338                 {
 339                         Match m = boxlsegRegex.Match(BackendData);
 340
 341                         return
 342                                 new NpgsqlLSeg(
 343                                         new NpgsqlPoint(Single.Parse(m.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
 344                                                                         Single.Parse(m.Groups[2].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)),
 345                                         new NpgsqlPoint(Single.Parse(m.Groups[3].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
 346                                                                         Single.Parse(m.Groups[4].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)));
 347                 }
 348
 349                 /// <summary>
 350                 /// Path.
 351                 /// </summary>
 352                 internal static Object ToPath(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 353                 {
 354                         Match m = pathpolygonRegex.Match(BackendData);
 355                         Boolean open = (BackendData[0] == '[');
 356                         List<NpgsqlPoint> points = new List<NpgsqlPoint>();
 357
 358                         while (m.Success)
 359                         {
 360                                 if (open)
 361                                 {
 362                                         points.Add(
 363                                                 new NpgsqlPoint(
 364                                                         Single.Parse(m.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
 365                                                         Single.Parse(m.Groups[2].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)));
 366                                 }
 367                                 else
 368                                 {
 369                                         // Here we have to do a little hack, because as of 2004-08-11 mono cvs version, the last group is returned with
 370                                         // a trailling ')' only when the last character of the string is a ')' which is the case for closed paths
 371                                         // returned by backend. This gives parsing exception when converting to single.
 372                                         // I still don't know if this is a bug in mono or in my regular expression.
 373                                         // Check if there is this character and remove it.
 374
 375                                         String group2 = m.Groups[2].ToString();
 376                                         if (group2.EndsWith(")"))
 377                                         {
 378                                                 group2 = group2.Remove(group2.Length - 1, 1);
 379                                         }
 380
 381                                         points.Add(
 382                                                 new NpgsqlPoint(
 383                                                         Single.Parse(m.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
 384                                                         Single.Parse(group2, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)));
 385                                 }
 386
 387                                 m = m.NextMatch();
 388                         }
 389
 390                         NpgsqlPath result = new NpgsqlPath(points.ToArray());
 391                         result.Open = open;
 392                         return result;
 393                 }
 394
 395                 /// <summary>
 396                 /// Polygon.
 397                 /// </summary>
 398                 internal static Object ToPolygon(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize,
 399                                                                                  Int32 TypeModifier)
 400                 {
 401                         Match m = pathpolygonRegex.Match(BackendData);
 402                         List<NpgsqlPoint> points = new List<NpgsqlPoint>();
 403
 404                         while (m.Success)
 405                         {
 406                                 // Here we have to do a little hack, because as of 2004-08-11 mono cvs version, the last group is returned with
 407                                 // a trailling ')' only when the last character of the string is a ')' which is the case for closed paths
 408                                 // returned by backend. This gives parsing exception when converting to single.
 409                                 // I still don't know if this is a bug in mono or in my regular expression.
 410                                 // Check if there is this character and remove it.
 411
 412                                 String group2 = m.Groups[2].ToString();
 413                                 if (group2.EndsWith(")"))
 414                                 {
 415                                         group2 = group2.Remove(group2.Length - 1, 1);
 416                                 }
 417
 418                                 points.Add(
 419                                         new NpgsqlPoint(Single.Parse(m.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
 420                                                                         Single.Parse(group2, NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)));
 421
 422
 423                                 m = m.NextMatch();
 424                         }
 425
 426                         return new NpgsqlPolygon(points);
 427                 }
 428
 429                 /// <summary>
 430                 /// Circle.
 431                 /// </summary>
 432                 internal static Object ToCircle(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 433                 {
 434                         Match m = circleRegex.Match(BackendData);
 435                         return
 436                                 new NpgsqlCircle(
 437                                         new NpgsqlPoint(Single.Parse(m.Groups[1].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat),
 438                                                                         Single.Parse(m.Groups[2].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat)),
 439                                         Single.Parse(m.Groups[3].ToString(), NumberStyles.Any, CultureInfo.InvariantCulture.NumberFormat));
 440                 }
 441
 442                 /// <summary>
 443                 /// Inet.
 444                 /// </summary>
 445                 internal static Object ToInet(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 446                 {
 447                         return new NpgsqlInet(BackendData);
 448                 }
 449
 450         internal static Object ToGuid(NpgsqlBackendTypeInfo TypeInfo, String BackendData, Int16 TypeSize, Int32 TypeModifier)
 451         {
 452             return new Guid(BackendData);
 453         }
 454
 455                 /// <summary>
 456                 /// interval
 457                 /// </summary>
 458                 internal static object ToInterval(NpgsqlBackendTypeInfo typeInfo, String backendData, Int16 typeSize,
 459                                                                                   Int32 typeModifier)
 460                 {
 461                         return NpgsqlInterval.Parse(backendData);
 462                 }
 463
 464                 internal static object ToTime(NpgsqlBackendTypeInfo typeInfo, String backendData, Int16 typeSize, Int32 typeModifier)
 465                 {
 466                         return NpgsqlTime.Parse(backendData);
 467                 }
 468
 469                 internal static object ToTimeTZ(NpgsqlBackendTypeInfo typeInfo, String backendData, Int16 typeSize, Int32 typeModifier)
 470                 {
 471                         return NpgsqlTimeTZ.Parse(backendData);
 472                 }
 473
 474                 internal static object ToDate(NpgsqlBackendTypeInfo typeInfo, String backendData, Int16 typeSize, Int32 typeModifier)
 475                 {
 476                         return NpgsqlDate.Parse(backendData);
 477                 }
 478
 479                 internal static object ToTimeStamp(NpgsqlBackendTypeInfo typeInfo, String backendData, Int16 typeSize,
 480                                                                                    Int32 typeModifier)
 481                 {
 482                         return NpgsqlTimeStamp.Parse(backendData);
 483                 }
 484
 485                 internal static object ToTimeStampTZ(NpgsqlBackendTypeInfo typeInfo, String backendData, Int16 typeSize,
 486                                                                                          Int32 typeModifier)
 487                 {
 488                         return NpgsqlTimeStampTZ.Parse(backendData);
 489                 }
 490         }
 491
 492         /// <summary>
 493         /// Provide event handlers to convert extended native supported data types from
 494         /// native form to backend representation.
 495         /// </summary>
 496         internal abstract class ExtendedNativeToBackendTypeConverter
 497         {
 498                 /// <summary>
 499                 /// Point.
 500                 /// </summary>
 501                 internal static String ToPoint(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 502                 {
 503                         if (NativeData is NpgsqlPoint)
 504                         {
 505                                 NpgsqlPoint P = (NpgsqlPoint)NativeData;
 506                                 return String.Format(CultureInfo.InvariantCulture, "({0},{1})", P.X, P.Y);
 507                         }
 508                         else
 509                         {
 510                                 throw new InvalidCastException("Unable to cast data to NpgsqlPoint type");
 511                         }
 512                 }
 513
 514                 /// <summary>
 515                 /// Box.
 516                 /// </summary>
 517                 internal static String ToBox(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 518                 {
 519                         /*if (NativeData.GetType() == typeof(Rectangle)) {
 520                 Rectangle       R = (Rectangle)NativeData;
 521                 return String.Format(CultureInfo.InvariantCulture, "({0},{1}),({2},{3})", R.Left, R.Top, R.Left + R.Width, R.Top + R.Height);
 522             } else if (NativeData.GetType() == typeof(RectangleF)) {
 523                 RectangleF      R = (RectangleF)NativeData;
 524                 return String.Format(CultureInfo.InvariantCulture, "({0},{1}),({2},{3})", R.Left, R.Top, R.Left + R.Width, R.Top + R.Height);*/
 525
 526                         if (NativeData is NpgsqlBox)
 527                         {
 528                                 NpgsqlBox box = (NpgsqlBox)NativeData;
 529                                 return
 530                                         String.Format(CultureInfo.InvariantCulture, "({0},{1}),({2},{3})", box.LowerLeft.X, box.LowerLeft.Y,
 531                                                                   box.UpperRight.X, box.UpperRight.Y);
 532                         }
 533                         else
 534                         {
 535                                 throw new InvalidCastException("Unable to cast data to Rectangle type");
 536                         }
 537                 }
 538
 539                 /// <summary>
 540                 /// LSeg.
 541                 /// </summary>
 542                 internal static String ToLSeg(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 543                 {
 544                         NpgsqlLSeg S = (NpgsqlLSeg)NativeData;
 545                         return String.Format(CultureInfo.InvariantCulture, "{0},{1},{2},{3}", S.Start.X, S.Start.Y, S.End.X, S.End.Y);
 546                 }
 547
 548                 /// <summary>
 549                 /// Open path.
 550                 /// </summary>
 551                 internal static String ToPath(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 552                 {
 553                         StringBuilder B = null;
 554                         try
 555                         {
 556         B =new StringBuilder();
 557
 558                         foreach (NpgsqlPoint P in ((NpgsqlPath)NativeData))
 559                         {
 560                                 B.AppendFormat(CultureInfo.InvariantCulture, "{0}({1},{2})", (B.Length > 0 ? "," : ""), P.X, P.Y);
 561                         }
 562
 563                         return String.Format("[{0}]", B);
 564                         }
 565                         finally
 566                         {
 567                                 B = null;
 568
 569                         }
 570
 571                 }
 572
 573                 /// <summary>
 574                 /// Polygon.
 575                 /// </summary>
 576                 internal static String ToPolygon(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 577                 {
 578                         StringBuilder B = new StringBuilder();
 579
 580                         foreach (NpgsqlPoint P in ((NpgsqlPolygon)NativeData))
 581                         {
 582                                 B.AppendFormat(CultureInfo.InvariantCulture, "{0}({1},{2})", (B.Length > 0 ? "," : ""), P.X, P.Y);
 583                         }
 584
 585                         return String.Format("({0})", B);
 586                 }
 587
 588                 /// <summary>
 589                 /// Circle.
 590                 /// </summary>
 591                 internal static String ToCircle(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 592                 {
 593                         NpgsqlCircle C = (NpgsqlCircle)NativeData;
 594                         return String.Format(CultureInfo.InvariantCulture, "{0},{1},{2}", C.Center.X, C.Center.Y, C.Radius);
 595                 }
 596
 597                 /// <summary>
 598                 /// Convert to a postgres inet.
 599                 /// </summary>
 600                 internal static String ToIPAddress(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 601                 {
 602                         if (NativeData is NpgsqlInet)
 603                         {
 604                                 return ((NpgsqlInet)NativeData).ToString();
 605                         }
 606                         return NativeData.ToString();
 607
 608                 }
 609
 610                 /// <summary>
 611                 /// Convert to a postgres interval
 612                 /// </summary>
 613                 internal static String ToInterval(NpgsqlNativeTypeInfo TypeInfo, Object NativeData)
 614                 {
 615                         return
 616                                 ((NativeData is TimeSpan)
 617                                         ? ((NpgsqlInterval)(TimeSpan)NativeData).ToString()
 618                                         : ((NpgsqlInterval)NativeData).ToString());
 619                 }
 620
 621                 internal static string ToTime(NpgsqlNativeTypeInfo typeInfo, object nativeData)
 622                 {
 623                         if (nativeData is DateTime)
 624                         {
 625                                 return BasicNativeToBackendTypeConverter.ToTime(typeInfo, nativeData);
 626                         }
 627                         NpgsqlTime time;
 628                         if (nativeData is TimeSpan)
 629                         {
 630                                 time = (NpgsqlTime)(TimeSpan)nativeData;
 631                         }
 632                         else
 633                         {
 634                                 time = (NpgsqlTime)nativeData;
 635                         }
 636                         return time.ToString();
 637                 }
 638
 639                 internal static string ToTimeTZ(NpgsqlNativeTypeInfo typeInfo, object nativeData)
 640                 {
 641                         if (nativeData is DateTime)
 642                         {
 643                                 return BasicNativeToBackendTypeConverter.ToTime(typeInfo, nativeData);
 644                         }
 645                         NpgsqlTimeTZ time;
 646                         if (nativeData is TimeSpan)
 647                         {
 648                                 time = (NpgsqlTimeTZ)(TimeSpan)nativeData;
 649                         }
 650                         else
 651                         {
 652                                 time = (NpgsqlTimeTZ)nativeData;
 653                         }
 654                         return time.ToString();
 655                 }
 656
 657                 internal static string ToDate(NpgsqlNativeTypeInfo typeInfo, object nativeData)
 658                 {
 659                         if (nativeData is DateTime)
 660                         {
 661                                 return BasicNativeToBackendTypeConverter.ToDate(typeInfo, nativeData);
 662                         }
 663                         else
 664                         {
 665                                 return nativeData.ToString();
 666                         }
 667                 }
 668
 669                 internal static string ToTimeStamp(NpgsqlNativeTypeInfo typeInfo, object nativeData)
 670                 {
 671                         if (nativeData is DateTime)
 672                         {
 673                                 return BasicNativeToBackendTypeConverter.ToDateTime(typeInfo, nativeData);
 674                         }
 675                         else
 676                         {
 677                                 return nativeData.ToString();
 678                         }
 679                 }
 680         }
 681 }