mcs/class/ByteFX.Data/mysqlclient/Field.cs

   1 // ByteFX.Data data access components for .Net
   2 // Copyright (C) 2002-2003  ByteFX, Inc.
   3 //
   4 // This library is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU Lesser General Public
   6 // License as published by the Free Software Foundation; either
   7 // version 2.1 of the License, or (at your option) any later version.
   8 //
   9 // This library is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // Lesser General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Lesser General Public
  15 // License along with this library; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17
  18 using System;
  19 using System.Data;
  20 using System.Data.SqlTypes;
  21 using System.Globalization;
  22 using System.Text;
  23 using ByteFX.Data.Common;
  24
  25 namespace ByteFX.Data.MySqlClient
  26 {
  27         internal enum ColumnFlags : int
  28         {
  29                 NOT_NULL                = 1,
  30                 PRIMARY_KEY             = 2,
  31                 UNIQUE_KEY              = 4,
  32                 MULTIPLE_KEY    = 8,
  33                 BLOB                    = 16,
  34                 UNSIGNED                = 32,
  35                 ZERO_FILL               = 64,
  36                 BINARY                  = 128,
  37                 ENUM                    = 256,
  38                 AUTO_INCREMENT  = 512,
  39                 TIMESTAMP               = 1024,
  40                 SET                             = 2048,
  41                 NUMBER                  = 32768
  42         };
  43
  44         /// <summary>
  45         /// Summary description for Field.
  46         /// </summary>
  47         internal class MySqlField : Common.Field
  48         {
  49                 protected       MySqlDbType     colType;
  50                 protected       ColumnFlags     colFlags;
  51                 protected       int                     colDecimals;
  52                 protected       Encoding        encoding;
  53                 private static NumberFormatInfo         numberFormat = null;
  54
  55                 protected       byte[]          buffer;
  56                 protected       long            bufIndex;
  57                 protected       long            bufLength;
  58
  59                 public MySqlField(Encoding encoding)
  60                 {
  61                         this.encoding = encoding;
  62                         if (numberFormat == null)
  63                         {
  64                                 numberFormat = (NumberFormatInfo)NumberFormatInfo.InvariantInfo.Clone();
  65                                 numberFormat.NumberDecimalSeparator = ".";
  66                         }
  67                 }
  68
  69                 public byte[] Buffer
  70                 {
  71                         get { return buffer; }
  72                 }
  73
  74                 public long     BufferIndex
  75                 {
  76                         get { return bufIndex; }
  77                 }
  78
  79                 public long BufferLength
  80                 {
  81                         get { return bufLength; }
  82                 }
  83
  84                 /// <summary>
  85                 /// CopyBuffer makes a copy of the byte buffer given to us while
  86                 /// the rowset was being read
  87                 /// </summary>
  88                 private void CopyBuffer()
  89                 {
  90                         byte[] newbuf = new byte[ bufLength ];
  91                         long oldIndex = bufIndex;
  92                         for (long i=0; i < bufLength; i++)
  93                                 newbuf[i] = buffer[ oldIndex++ ];
  94                         bufIndex = 0;
  95                         buffer = newbuf;
  96                         value = newbuf;
  97                 }
  98
  99                 /// <summary>
 100                 /// GetValue returns an object that represents the value of this field.
 101                 /// </summary>
 102                 /// <returns></returns>
 103                 public object GetValue()
 104                 {
 105                         // if our value is a byte buffer and we are using only
 106                         // a part of that buffer, then we need to make a copy
 107                         if (value is byte[] && (bufIndex > 0 || bufLength < buffer.Length))
 108                                 CopyBuffer();
 109                         return value;
 110                 }
 111
 112                 public MySqlDbType      Type
 113                 {
 114                         get { return colType; }
 115                         set { colType = value; }
 116                 }
 117
 118                 public int NumericPrecision
 119                 {
 120                         get
 121                         {
 122                                 if (colType == MySqlDbType.Decimal)
 123                                         return colLen;
 124                                 return -1;
 125                         }
 126
 127                 }
 128
 129                 public int NumericScale
 130                 {
 131                         get
 132                         {
 133                                 if (colType == MySqlDbType.Decimal)
 134                                         return colDecimals;
 135                                 return -1;
 136                         }
 137                         set
 138                         {
 139                                 colDecimals = value;
 140                         }
 141                 }
 142
 143                 public ColumnFlags Flags
 144                 {
 145                         get { return colFlags; }
 146                         set { colFlags = value; }
 147                 }
 148
 149                 public bool IsAutoIncrement()
 150                 {
 151                         return (colFlags & ColumnFlags.AUTO_INCREMENT) > 0;
 152                 }
 153
 154                 public bool IsNumeric()
 155                 {
 156                         return (colFlags & ColumnFlags.NUMBER) > 0;
 157                 }
 158
 159                 public bool AllowsNull()
 160                 {
 161                         return (colFlags & ColumnFlags.NOT_NULL) == 0;
 162                 }
 163
 164                 public bool IsUnique()
 165                 {
 166                         return (colFlags & ColumnFlags.UNIQUE_KEY) > 0;
 167                 }
 168
 169                 public bool IsPrimaryKey()
 170                 {
 171                         return (colFlags & ColumnFlags.PRIMARY_KEY) > 0;
 172                 }
 173
 174                 public bool IsBlob()
 175                 {
 176                         return (colFlags & ColumnFlags.BLOB) > 0;
 177                 }
 178
 179                 public bool IsBinary()
 180                 {
 181                         return (colFlags & ColumnFlags.BINARY) > 0;
 182                 }
 183
 184                 public bool IsUnsigned()
 185                 {
 186                         return (colFlags & ColumnFlags.UNSIGNED) > 0;
 187                 }
 188
 189                 public void SetValueData( byte[] buf, long index, long len, DBVersion version )
 190                 {
 191                         if (len == -1)
 192                         {
 193                                 value = DBNull.Value;
 194                                 buffer = null;
 195                                 return;
 196                         }
 197
 198                         buffer = buf;
 199                         bufIndex = index;
 200                         bufLength = len;
 201
 202                         // if it is a blob and binary, then GetBytes is the way to go
 203                         if ( IsBlob() && IsBinary() )
 204                         {
 205                                 dbType = DbType.Binary;
 206                                 value = buffer;
 207                                 return;
 208                         }
 209
 210                         string sValue = encoding.GetString( buf, (int)index, (int)len );
 211
 212                         switch(colType)
 213                         {
 214                                 case MySqlDbType.Byte:
 215                                         if (IsUnsigned())
 216                                                 value = Byte.Parse( sValue );
 217                                         else
 218                                                 value = SByte.Parse( sValue );
 219                                         break;
 220
 221                                 case MySqlDbType.Short:
 222                                         if (IsUnsigned())
 223                                                 value = UInt16.Parse( sValue );
 224                                         else
 225                                                 value = Int16.Parse( sValue );
 226                                         break;
 227
 228                                 case MySqlDbType.Int :
 229                                 case MySqlDbType.Int24:
 230                                         if (IsUnsigned())
 231                                                 value = UInt32.Parse( sValue );
 232                                         else
 233                                                 value = Int32.Parse( sValue );
 234                                         break;
 235
 236                                 case MySqlDbType.BigInt:
 237                                         if (IsUnsigned())
 238                                                 value = UInt64.Parse( sValue );
 239                                         else
 240                                                 value = Int64.Parse( sValue );
 241                                         break;
 242
 243                                 case MySqlDbType.Decimal:
 244                                         value = Decimal.Parse( sValue , numberFormat );
 245                                         break;
 246
 247                                 case MySqlDbType.Float:
 248                                         value = Convert.ToSingle( sValue, numberFormat );
 249                                         break;
 250
 251                                 case MySqlDbType.Double:
 252                                         value = Convert.ToDouble( sValue, numberFormat );
 253                                         break;
 254
 255                                 case MySqlDbType.Year:
 256                                         value = Int32.Parse( sValue );
 257                                         break;
 258
 259                                 case MySqlDbType.Date:
 260                                         ParseDateValue( "0000-00-00", "yyyy-MM-dd", sValue );
 261                                         break;
 262
 263                                 case MySqlDbType.Datetime:
 264                                         ParseDateValue( "0000-00-00 00:00:00", "yyyy-MM-dd HH:mm:ss", sValue );
 265                                         break;
 266
 267                                 case MySqlDbType.Time:
 268                                         if (sValue.Equals("00:00:00"))
 269                                                 value = DBNull.Value;
 270                                         else
 271                                                 value = TimeSpan.Parse(sValue);
 272                                         break;
 273
 274                                 case MySqlDbType.Timestamp:
 275                                         // MySql 4.1.0 and later use DateTime format for timestamp
 276                                         if (version.isAtLeast(4,1,0))
 277                                         {
 278                                                 ParseDateValue( "0000-00-00 00:00:00", "yyyy-MM-dd HH:mm:ss", sValue );
 279                                                 return;
 280                                         }
 281
 282                                         string pattern;
 283                                         string null_value = "00000000000000";
 284                                         switch (ColumnLength)
 285                                         {
 286                                                 case 2:  pattern = "yy"; break;
 287                                                 case 4:  pattern = "yyMM"; break;
 288                                                 case 6:  pattern = "yyMMdd"; break;
 289                                                 case 8:  pattern = "yyyyMMdd"; break;
 290                                                 case 10: pattern = "yyMMddHHmm"; break;
 291                                                 case 12: pattern = "yyMMddHHmmss"; break;
 292                                                 case 14:
 293                                                 default: pattern = "yyyyMMddHHmmss"; break;
 294                                         }
 295
 296                                         if (ColumnLength > 2 && sValue.Equals( null_value.Substring(0, ColumnLength)))
 297                                                 value = DBNull.Value;
 298                                         else
 299                                                 value = DateTime.ParseExact( sValue, pattern, new System.Globalization.DateTimeFormatInfo());
 300                                         break;
 301
 302                                 case MySqlDbType.String:
 303                                 case MySqlDbType.VarChar:
 304                                 case MySqlDbType.Blob:
 305                                 case MySqlDbType.TinyBlob:
 306                                 case MySqlDbType.LongBlob:
 307                                 case MySqlDbType.MediumBlob:
 308                                         value = sValue;
 309                                         break;
 310
 311                                 default:
 312                                         throw new NotSupportedException();
 313                         }
 314                 }
 315
 316                 protected void ParseDateValue( string nullpattern, string pattern, string data )
 317                 {
 318                         if ( data.Equals (nullpattern) )
 319                                 value = DBNull.Value;
 320                         else
 321                                 value = DateTime.ParseExact( data, pattern, new System.Globalization.DateTimeFormatInfo());
 322                 }
 323
 324                 public string GetFieldTypeName()
 325                 {
 326                         switch (colType)
 327                         {
 328                                 case MySqlDbType.Decimal:               return "DECIMAL";
 329                                 case MySqlDbType.Byte:                  return "TINY";
 330                                 case MySqlDbType.Short:                 return "SHORT";
 331                                 case MySqlDbType.Int:                   return "INTEGER";
 332                                 case MySqlDbType.Float:                 return "FLOAT";
 333                                 case MySqlDbType.Double:                return "DOUBLE";
 334                                 case MySqlDbType.Null:                  return "NULL";
 335                                 case MySqlDbType.Timestamp:             return "TIMESTAMP";
 336                                 case MySqlDbType.BigInt:                return "BIGINT";
 337                                 case MySqlDbType.Int24:                 return "INT24";
 338                                 case MySqlDbType.Date:                  return "DATE";
 339                                 case MySqlDbType.Time:                  return "TIME";
 340                                 case MySqlDbType.Datetime:              return "DATETIME";
 341                                 case MySqlDbType.Year:                  return "YEAR";
 342                                 case MySqlDbType.Newdate:               return "NEWDATE";
 343                                 case MySqlDbType.Enum:                  return "ENUM";
 344                                 case MySqlDbType.Set:                   return "SET";
 345                                 case MySqlDbType.TinyBlob:              return "TINY_BLOB";
 346                                 case MySqlDbType.MediumBlob:    return "MEDIUM_BLOB";
 347                                 case MySqlDbType.LongBlob:              return "LONG_BLOB";
 348                                 case MySqlDbType.Blob:                  return "BLOB";
 349                                 case MySqlDbType.VarChar:       return "VAR_STRING";
 350                                 case MySqlDbType.String:                return "STRING";
 351                         }
 352                         return "Unknown typeid";
 353                 }
 354
 355
 356                 public Type GetFieldType()
 357                 {
 358                         switch (colType)
 359                         {
 360                                 case MySqlDbType.Byte:          return IsUnsigned() ? typeof(System.Byte) : typeof(System.SByte);
 361
 362                                 case MySqlDbType.Short:         return IsUnsigned() ? typeof(System.UInt16) : typeof(System.Int16);
 363
 364                                 case MySqlDbType.Int:
 365                                 case MySqlDbType.Int24:         return IsUnsigned() ? typeof(System.UInt32) : typeof(System.Int32);
 366
 367                                 case MySqlDbType.BigInt:        return IsUnsigned() ? typeof(System.UInt64) : typeof(System.Int64);
 368
 369                                 case MySqlDbType.Float:         return typeof(System.Single);
 370                                 case MySqlDbType.Double:                return typeof(System.Double);
 371
 372                                 case MySqlDbType.Time:          return typeof(System.TimeSpan);
 373
 374                                 case MySqlDbType.Date:
 375                                 case MySqlDbType.Datetime:
 376                                 case MySqlDbType.Timestamp:     return typeof(System.DateTime);
 377
 378                                 case MySqlDbType.Decimal:       return typeof(System.Decimal);
 379
 380                                 case MySqlDbType.VarChar:
 381                                 case MySqlDbType.String:                return typeof(System.String);
 382
 383                                 case MySqlDbType.TinyBlob:
 384                                 case MySqlDbType.MediumBlob:
 385                                 case MySqlDbType.LongBlob:
 386                                 case MySqlDbType.Blob:
 387                                         if ((colFlags & ColumnFlags.BINARY) != 0)
 388                                                 return typeof(System.Array);
 389                                         else
 390                                                 return typeof(System.String);
 391
 392                                 case MySqlDbType.Year:
 393                                         return typeof(System.Int32);
 394
 395                                 default:
 396                                 case MySqlDbType.Null:          return typeof(System.DBNull);
 397                         }
 398                 }
 399
 400                 public DbType GetDbType()
 401                 {
 402                         switch (colType)
 403                         {
 404                                 case MySqlDbType.Decimal:               return DbType.Decimal;
 405                                 case MySqlDbType.Byte:                  return DbType.Byte;
 406                                 case MySqlDbType.Short:
 407                                         if (IsUnsigned())
 408                                                 return DbType.UInt16;
 409                                         else
 410                                                 return DbType.Int16;
 411
 412                                 case MySqlDbType.Int:
 413                                         if (IsUnsigned())
 414                                                 return DbType.UInt32;
 415                                         else
 416                                                 return DbType.Int32;
 417
 418                                 case MySqlDbType.Float:                 return DbType.Single;
 419                                 case MySqlDbType.Double:                return DbType.Double;
 420                                 case MySqlDbType.Null:                  return DbType.Object;
 421
 422                                 case MySqlDbType.BigInt:
 423                                         if (IsUnsigned())
 424                                                 return DbType.UInt64;
 425                                         else
 426                                                 return DbType.Int64;
 427
 428                                 case MySqlDbType.Int24:
 429                                         if (IsUnsigned())
 430                                                 return DbType.UInt32;
 431                                         else
 432                                                 return DbType.Int32;
 433                                 case MySqlDbType.Date:
 434                                 case MySqlDbType.Year:
 435                                 case MySqlDbType.Newdate:
 436                                         return DbType.Date;
 437
 438                                 case MySqlDbType.Time:
 439                                         return DbType.Time;
 440                                 case MySqlDbType.Datetime:
 441                                 case MySqlDbType.Timestamp:
 442                                         return DbType.DateTime;
 443
 444                                 case MySqlDbType.Enum:                  return DbType.UInt32;
 445                                 case MySqlDbType.Set:                   return DbType.Object;
 446
 447                                 case MySqlDbType.TinyBlob:
 448                                 case MySqlDbType.MediumBlob:
 449                                 case MySqlDbType.LongBlob:
 450                                 case MySqlDbType.Blob:
 451                                         if (IsBinary()) return DbType.Binary;
 452                                         return DbType.String;
 453                                 case MySqlDbType.VarChar:
 454                                         return DbType.String;
 455                                 case MySqlDbType.String:
 456                                         return DbType.StringFixedLength;
 457                         }
 458                         throw new Exception("unknown MySqlDbType");
 459                 }
 460
 461         }
 462
 463 }