Example #1
0
        private ArrayList schemaTables = null;               // GENERICS: List<DataTable>

        /// <summary>
        /// Gets information about schema of the current result set.
        /// </summary>
        /// <returns>Schema table.</returns>
        public DataTable GetSchemaTable()
        {
            // loads schema if not loaded yet:
            if (schemaTables == null)
            {
                connection.ReexecuteSchemaQuery(this);
                if (reader.IsClosed)
                {
                    PhpException.Throw(PhpError.Warning, LibResources.GetString("cannot_retrieve_schema"));
                    return(null);
                }

                schemaTables = new ArrayList();
                do
                {
                    schemaTables.Add(reader.GetSchemaTable());
                }while (reader.NextResult());
            }

            return((DataTable)schemaTables[currentSetIndex]);
        }
Example #2
0
        internal static PhpMyDbConnection ValidConnection(PhpResource handle)
        {
            PhpMyDbConnection connection;

            if (handle != null && handle.GetType() == typeof(PhpMyDbConnection))
            {
                connection = (PhpMyDbConnection)handle;
            }
            else
            {
                connection = null;
            }

            if (connection != null && connection.IsValid)
            {
                return(connection);
            }

            PhpException.Throw(PhpError.Warning, LibResources.GetString("invalid_connection_resource"));
            return(null);
        }
Example #3
0
        public static int Parse(string /*!*/ str, DateTime utcStart, out string error)
        {
            Debug.Assert(str != null);

            var scanner = new Scanner(new StringReader(str.ToLowerInvariant()));

            while (true)
            {
                Tokens token = scanner.GetNextToken();
                if (token == Tokens.ERROR || scanner.Errors > 0)
                {
                    error = LibResources.GetString("parse_error", scanner.Position, str.Substring(scanner.Position));
                    return(0);
                }

                if (token == Tokens.EOF)
                {
                    return(scanner.Time.GetUnixTimeStamp(utcStart, out error));
                }
            }
        }
Example #4
0
        /// <summary>
        /// Implementation of <c>mb_strr[i]pos</c> functions.
        /// </summary>
        private static int Strrpos(object haystack, object needle, int offset, getEncoding encodingGetter, bool ignoreCase)
        {
            string uhaystack = ObjectToString(haystack, encodingGetter);
            string uneedle   = ObjectToString(needle, encodingGetter);

            if (uhaystack == null || uneedle == null)
            {
                return(-1);
            }

            int end = uhaystack.Length - 1;

            if (offset > end || offset < -end - 1)
            {
                PhpException.InvalidArgument("offset", LibResources.GetString("arg:out_of_bounds"));
                return(-1);
            }

            if (offset < 0)
            {
                end   += uneedle.Length + offset;
                offset = 0;
            }

            if (uneedle.Length == 0)
            {
                PhpException.InvalidArgument("needle", LibResources.GetString("arg:empty"));
                return(-1);
            }

            if (ignoreCase)
            {
                return(uhaystack.ToLower().LastIndexOf(uneedle.ToLower(), end, end - offset + 1));
            }
            else
            {
                return(uhaystack.LastIndexOf(uneedle, end, end - offset + 1));
            }
        }
Example #5
0
        /// <summary>
        /// Changes the active database on opened connection.
        /// </summary>
        /// <param name="databaseName"></param>
        /// <returns>true if databse was changed; otherwise returns false</returns>
        public bool SelectDb(string databaseName)
        {
            ClosePendingReader();

            try
            {
                if (this.connection.State == ConnectionState.Open)
                {
                    connection.ChangeDatabase(databaseName);
                    lastException = null;
                    return(true);
                }
            }
            catch (Exception e)
            {
                lastException = e;
                PhpException.Throw(PhpError.Warning, LibResources.GetString("database_selection_failed",
                                                                            GetExceptionMessage(e)));
            }

            return(false);
        }
Example #6
0
        /// <summary>
        /// Closes connection and releases the resource.
        /// </summary>
        protected override void FreeManaged()
        {
            base.FreeManaged();

            ClosePendingReader();

            try
            {
                if (connection != null)
                {
                    connection.Close();
                }
                lastException = null;
            }
            catch (Exception e)
            {
                lastException = e;
                PhpException.Throw(PhpError.Warning, LibResources.GetString("error_closing_connection",
                                                                            GetExceptionMessage(e)));
            }
            connection = null;
        }
Example #7
0
        public static string GuidToString(PhpBytes binary, bool shortFormat)
        {
            if (binary == null || binary.Length == 0)
            {
                return(String.Empty);
            }

            if (binary.Length != 16)
            {
                PhpException.InvalidArgument("binary", LibResources.GetString("arg:invalid_length"));
                return(null);
            }

            if (shortFormat)
            {
                return(new Guid(binary.ReadonlyData).ToString("D").ToUpper());
            }
            else
            {
                return(PHP.Core.StringUtils.BinToHex(binary.ReadonlyData, null).ToUpper());
            }
        }
Example #8
0
        /// <summary>
        /// Parses pack format. Stores specifiers and repeaters into the respective arrays.
        /// Repeaters are ensured to be finite and non-negative (infinite repeaters are converted to finite).
        /// Some arguments are also converted to another form (e.g. to string) because we will need that form later.
        /// </summary>
        /// <returns>Returns the number of parsed specifiers or 0 on error.</returns>
        static int ParseFormat(Context ctx, string format, PhpValue[] args, char[] specifiers, int[] repeaters)
        {
            var encoding = ctx.StringEncoding;

            int i      = 0;  // current position in format
            int a      = 0;  // current argument index
            int result = 0;  // number of parsed specifiers

            while (i < format.Length)
            {
                char specifier = format[i++];
                int  repeater  = ParseRepeater(format, ref i);

                switch (specifier)
                {
                case 'x':     // NUL byte
                case '@':     // NUL-fill to absolute position
                case 'X':     // Back up one byte

                    // consumes no arguments => repeater cannot be '*'
                    if (repeater == InfiniteRepeater)
                    {
                        PhpException.Throw(PhpError.Warning, LibResources.GetString("asterisk_ignored", specifier));
                        repeater = 1;
                    }
                    break;

                case 'Z':     // equivalent functionality to "a" for Perl compatibility
                case 'a':     // NUL-padded string
                case 'A':     // SPACE-padded string
                case 'h':     // Hex string, low/high nibble first - converts to a string, takes n hex digits:
                case 'H':
                {
                    // consumes one argument:
                    if (a == args.Length)
                    {
                        PhpException.Throw(PhpError.Warning, LibResources.GetString("not_enought_arguments", specifier));
                        return(0);
                    }

                    // converts the current argument to a string and stores it back:
                    string s = args[a].ToString(ctx);
                    args[a] = (PhpValue)s;
                    a++;

                    if (specifier == 'h' || specifier == 'H')
                    {
                        if (repeater > s.Length)
                        {
                            PhpException.Throw(PhpError.Warning, LibResources.GetString("not_enought_characters", specifier));
                            repeater = s.Length;
                        }
                    }
                    else
                    {
                        if (encoding.GetByteCount(s) != s.Length)
                        {
                            PhpException.Throw(PhpError.Warning, LibResources.GetString("multibyte_chars_unsupported", specifier));
                            return(0);
                        }
                    }

                    // adjusts infinite repeater to the string length:
                    if (repeater == InfiniteRepeater)
                    {
                        repeater = s.Length;
                    }

                    break;
                }

                case 'c':     // signed char
                case 'C':     // unsigned char
                case 's':     // signed short (always 16 bit, machine byte order)
                case 'S':     // unsigned short (always 16 bit, machine byte order)
                case 'n':     // unsigned short (always 16 bit, big endian byte order)
                case 'v':     // unsigned short (always 16 bit, little endian byte order)
                case 'i':     // signed integer (machine dependent size and byte order)
                case 'I':     // unsigned integer (machine dependent size and byte order)
                case 'l':     // signed long (always 32 bit, machine byte order)
                case 'L':     // unsigned long (always 32 bit, machine byte order)
                case 'N':     // unsigned long (always 32 bit, big endian byte order)
                case 'V':     // unsigned long (always 32 bit, little endian byte order)
                case 'f':     // float (machine dependent size and representation)
                case 'd':     // double (machine dependent size and representation)

                    if (repeater == InfiniteRepeater)
                    {
                        // infinite repeater is converted to the number of remaining arguments (can be zero):
                        repeater = args.Length - a;
                    }
                    else if (repeater > args.Length - a)
                    {
                        PhpException.Throw(PhpError.Warning, LibResources.GetString("not_enought_arguments", specifier));
                        return(0);
                    }

                    // consume arguments:
                    a += repeater;
                    break;

                default:
                    PhpException.Throw(PhpError.Warning, LibResources.GetString("unknown_format_code", specifier));
                    return(0);
                }

                specifiers[result] = specifier;
                repeaters[result]  = repeater;
                result++;
            }

            // reports unused arguments:
            if (a < args.Length)
            {
                PhpException.Throw(PhpError.Warning, LibResources.GetString("unused_arguments", args.Length - a));
            }

            return(result);
        }
Example #9
0
        /// <summary>
        /// Unpacks data from a string of bytes into <see cref="PhpArray"/>.
        /// </summary>
        /// <param name="ctx">Runtime context.</param>
        /// <param name="format">The string defining the items of the result. See PHP manual for details.</param>
        /// <param name="data">The string of bytes to be unpacked.</param>
        /// <returns>The <see cref="PhpArray"/> containing unpacked data.</returns>
        public static PhpArray unpack(Context ctx, string format, PhpString data)
        {
            if (format == null)
            {
                return(null);
            }
            byte[] buffer = data.ToBytes(ctx);

            var encoding = ctx.StringEncoding;

            byte[] reversed = new byte[4]; // used for reversing the order of bytes in buffer

            int      i      = 0;
            int      pos    = 0;
            PhpArray result = new PhpArray();

            while (i < format.Length)
            {
                string name;
                int    repeater;
                char   specifier;

                // parses specifier, repeater, and name from the format string:
                ParseFormatToken(format, ref i, out specifier, out repeater, out name);

                int remains = buffer.Length - pos;          // the number of bytes remaining in the buffer
                int size;                                   // a size of data to be extracted corresponding to the specifier

                // repeater of '@' specifier has a special meaning:
                if (specifier == '@')
                {
                    if (repeater > buffer.Length || repeater == InfiniteRepeater)
                    {
                        PhpException.Throw(PhpError.Warning, LibResources.GetString("outside_string", specifier));
                    }
                    else
                    {
                        pos = repeater;
                    }

                    continue;
                }

                // number of operations:
                int op_count;

                // gets the size of the data to read and adjust repeater:
                if (!GetSizeToUnpack(specifier, remains, repeater, out op_count, out size))
                {
                    PhpException.Throw(PhpError.Warning, LibResources.GetString("unknown_format_code", specifier));
                    return(null);
                }

                // repeats operation determined by specifier "op_count" times;
                // if op_count is infinite then stops when the number of remaining characters is zero:
                for (int j = 0; j < op_count || op_count == InfiniteRepeater; j++)
                {
                    if (size > remains)
                    {
                        // infinite means "while data are available":
                        if (op_count == InfiniteRepeater)
                        {
                            break;
                        }

                        PhpException.Throw(PhpError.Warning, LibResources.GetString("not_enought_input", specifier, size, remains));
                        return(null);
                    }

                    PhpValue item;
                    switch (specifier)
                    {
                    case 'X':     // decreases position, no value stored:
                        if (pos == 0)
                        {
                            PhpException.Throw(PhpError.Warning, LibResources.GetString("outside_string", specifier));
                        }
                        else
                        {
                            pos--;
                        }
                        continue;

                    case 'x':     // advances position, no value stored
                        pos++;
                        continue;

                    case 'a':     // NUL-padded string
                    case 'A':     // SPACE-padded string
                    {
                        byte pad = (byte)(specifier == 'a' ? 0x00 : 0x20);

                        int last = pos + size - 1;
                        while (last >= pos && buffer[last] == pad)
                        {
                            last--;
                        }

                        item = (PhpValue)encoding.GetString(buffer, pos, last - pos + 1);
                        break;
                    }

                    case 'h':     // Hex string, low/high nibble first - converts to a string, takes n hex digits from string:
                    case 'H':
                    {
                        int p            = pos;
                        int nibble_shift = (specifier == 'h') ? 0 : 4;

                        var sb = StringBuilderUtilities.Pool.Get();
                        for (int k = 0; k < size; k++)
                        {
                            const string hex_digits = "0123456789ABCDEF";

                            sb.Append(hex_digits[(buffer[p] >> nibble_shift) & 0x0f]);

                            // beware of odd repeaters!
                            if (repeater == InfiniteRepeater || repeater > sb.Length)
                            {
                                sb.Append(hex_digits[(buffer[p] >> (4 - nibble_shift)) & 0x0f]);
                            }
                            p++;
                        }

                        item = StringBuilderUtilities.GetStringAndReturn(sb);
                        break;
                    }

                    case 'c':     // signed char
                        item = (PhpValue)(int)unchecked ((sbyte)buffer[pos]);
                        break;

                    case 'C':     // unsigned char
                        item = (PhpValue)(int)buffer[pos];
                        break;

                    case 's':     // signed short (always 16 bit, machine byte order)
                        item = (PhpValue)(int)BitConverter.ToInt16(buffer, pos);
                        break;

                    case 'S':     // unsigned short (always 16 bit, machine byte order)
                        item = (PhpValue)(int)BitConverter.ToUInt16(buffer, pos);
                        break;

                    case 'n':     // unsigned short (always 16 bit, big endian byte order)
                        if (BitConverter.IsLittleEndian)
                        {
                            item = (PhpValue)(int)BitConverter.ToUInt16(LoadReverseBuffer(reversed, buffer, pos, 2), 0);
                        }
                        else
                        {
                            item = (PhpValue)(int)BitConverter.ToUInt16(buffer, pos);
                        }
                        break;

                    case 'v':     // unsigned short (always 16 bit, little endian byte order)
                        if (!BitConverter.IsLittleEndian)
                        {
                            item = (PhpValue)(int)BitConverter.ToUInt16(LoadReverseBuffer(reversed, buffer, pos, 2), 0);
                        }
                        else
                        {
                            item = (PhpValue)(int)BitConverter.ToUInt16(buffer, pos);
                        }
                        break;

                    case 'i':     // signed integer (machine dependent size and byte order - always 32 bit)
                    case 'I':     // unsigned integer (machine dependent size and byte order - always 32 bit)
                    case 'l':     // signed long (always 32 bit, machine byte order)
                    case 'L':     // unsigned long (always 32 bit, machine byte order)
                        item = (PhpValue)BitConverter.ToInt32(buffer, pos);
                        break;

                    case 'N':     // unsigned long (always 32 bit, big endian byte order)
                        item = (PhpValue) unchecked (((int)buffer[pos] << 24) + (buffer[pos + 1] << 16) + (buffer[pos + 2] << 8) + buffer[pos + 3]);
                        break;

                    case 'V':     // unsigned long (always 32 bit, little endian byte order)
                        item = (PhpValue) unchecked (((int)buffer[pos + 3] << 24) + (buffer[pos + 2] << 16) + (buffer[pos + 1] << 8) + buffer[pos + 0]);
                        break;

                    case 'f':     // float (machine dependent size and representation - size is always 4B)
                        item = (PhpValue)(double)BitConverter.ToSingle(buffer, pos);
                        break;

                    case 'd':     // double (machine dependent size and representation - size is always 8B)
                        item = (PhpValue)BitConverter.ToDouble(buffer, pos);
                        break;

                    default:
                        Debug.Fail("Invalid specifier.");
                        return(null);
                    }

                    AddValue(result, name, item, op_count, j);

                    pos     += size;
                    remains -= size;
                }
            }

            return(result);
        }
Example #10
0
        /// <summary>
        /// Packs arguments into the buffer according to given specifiers and repeaters.
        /// Count specifies the number of valid specifiers/repeaters.
        /// </summary>
        static void PackInternal(Context ctx, byte[] buffer, PhpValue[] args, char[] specifiers, int[] repeaters, int count)
        {
            var  encoding = ctx.StringEncoding;
            bool le       = BitConverter.IsLittleEndian;
            int  a        = 0;    // index of the current argument
            int  pos      = 0;    // the position in the buffer

            PhpNumber num;
            bool      le2;

            for (int i = 0; i < count; i++)
            {
                char specifier = specifiers[i];
                int  repeater  = repeaters[i];

                switch (specifier)
                {
                case 'x':
                    // NUL byte repeated for "repeater" count:
                    ArrayUtils.Fill(buffer, 0, pos, repeater);
                    pos += repeater;
                    break;

                case '@':
                    // NUL-fill to absolute position;
                    // if it is less then the current position the result is shortened
                    if (repeater > pos)
                    {
                        ArrayUtils.Fill(buffer, 0, pos, repeater - pos);
                    }
                    pos = repeater;
                    break;

                case 'X':
                    pos = Math.Max(0, pos - repeater);
                    break;

                case 'a':     // NUL-padded string
                case 'A':     // SPACE-padded string
                {
                    // argument has already been converted to string:
                    string s = args[a++].ToString(ctx);

                    int length     = Math.Min(s.Length, repeater);
                    int byte_count = encoding.GetBytes(s, 0, length, buffer, pos);
                    Debug.Assert(byte_count == length, "Multibyte characters not supported");

                    // padding:
                    if (repeater > length)
                    {
                        ArrayUtils.Fill(buffer, (byte)((specifier == 'a') ? 0x00 : 0x20), pos + length, repeater - length);
                    }

                    pos += repeater;
                    break;
                }

                case 'h':     // Hex string, low/high nibble first - converts to a string, takes n hex digits from string:
                case 'H':
                {
                    // argument has already been converted to string:
                    string s = args[a++].ToString(ctx);

                    int nibble_shift = (specifier == 'h') ? 0 : 4;

                    for (int j = 0; j < repeater; j++)
                    {
                        int digit = Core.Convert.AlphaNumericToDigit(s[j]);
                        if (digit > 15)
                        {
                            PhpException.Throw(PhpError.Warning, LibResources.GetString("illegal_hex_digit", specifier, s[j]));
                            digit = 0;
                        }

                        if (j % 2 == 0)
                        {
                            buffer[pos] = unchecked ((byte)(digit << nibble_shift));
                        }
                        else
                        {
                            buffer[pos] |= unchecked ((byte)(digit << (4 - nibble_shift)));
                            pos++;
                        }
                    }

                    // odd number of hex digits (append '0' digit):
                    if (repeater % 2 == 1)
                    {
                        pos++;
                    }

                    break;
                }

                case 'c':     // signed char
                case 'C':     // unsigned char
                    while (repeater-- > 0)
                    {
                        buffer[pos++] = unchecked ((byte)args[a++].ToLong());
                    }
                    break;

                case 's':     // signed short (always 16 bit, machine byte order)
                case 'S':     // unsigned short (always 16 bit, machine byte order)
                    while (repeater-- > 0)
                    {
                        var ni = args[a++].ToNumber(out num);
                        PackNumber(BitConverter.GetBytes(unchecked ((ushort)num.ToLong())), le, buffer, ref pos);
                    }
                    break;

                case 'n':     // unsigned short (always 16 bit, big endian byte order)
                case 'v':     // unsigned short (always 16 bit, little endian byte order)
                    while (repeater-- > 0)
                    {
                        PackNumber(BitConverter.GetBytes(unchecked ((ushort)args[a++].ToLong())), specifier == 'v', buffer, ref pos);
                    }
                    break;

                case 'i':     // signed integer (machine dependent size and byte order - always 32 bit)
                case 'I':     // signed integer (machine dependent size and byte order - always 32 bit)
                case 'l':     // signed long (always 32 bit, machine byte order)
                case 'L':     // unsigned long (always 32 bit, machine byte order)
                    while (repeater-- > 0)
                    {
                        PackNumber(BitConverter.GetBytes((int)args[a++].ToLong()), le, buffer, ref pos);
                    }
                    break;

                case 'N':     // unsigned long (always 32 bit, big endian byte order)
                case 'V':     // unsigned long (always 32 bit, little endian byte order)
                    while (repeater-- > 0)
                    {
                        PackNumber(BitConverter.GetBytes((int)args[a++].ToLong()), specifier == 'V', buffer, ref pos);
                    }
                    break;

                case 'f':     // float (machine dependent size and representation - size is always 4B)
                case 'g':     // float (machine dependent size, little endian byte order)
                case 'G':     // float (machine dependent size, big endian byte order)
                    le2 = specifier == 'f' ? le : (specifier == 'g');
                    while (repeater-- > 0)
                    {
                        PackNumber(BitConverter.GetBytes(unchecked ((float)args[a++].ToDouble())), le2, buffer, ref pos);
                    }
                    break;

                case 'd':     // double (machine dependent size and representation - size is always 8B)
                case 'e':     // double (machine dependent size, little endian byte order)
                case 'E':     // double (machine dependent size, big endian byte order)
                    le2 = specifier == 'd' ? le : (specifier == 'e');
                    while (repeater-- > 0)
                    {
                        PackNumber(BitConverter.GetBytes(args[a++].ToDouble()), le2, buffer, ref pos);
                    }
                    break;

                default:
                    Debug.Fail("Invalid specifier");
                    break;
                }
            }
        }
Example #11
0
        /// <summary>
        /// Computes the total size of binary data according to given specifiers and repeaters.
        /// Only <c>count</c> of them are valid.
        /// </summary>
        static void GetPackedDataSize(char[] specifiers, int[] repeaters, int count, out int resultLength, out int maxLength)
        {
            long result = 0;

            maxLength = 0;

            for (int i = 0; i < count; i++)
            {
                long repeater  = repeaters[i];
                char specifier = specifiers[i];

                switch (specifier)
                {
                case 'x':
                    // NUL byte repeated for "repeater" count:
                    result += repeater;
                    break;

                case '@':
                    // NUL-fill to absolute position;
                    // if it is less then the current position the result is shortened
                    result = repeater;
                    break;

                case 'X':
                    // shortens the result by "repeater" bytes (underflow has to be checked):
                    if (result < repeater)
                    {
                        PhpException.Throw(PhpError.Warning, LibResources.GetString("outside_string", specifier));
                        result = 0;
                    }
                    else
                    {
                        result -= repeater;
                    }
                    break;

                case 'a':     // NUL-padded string
                case 'A':     // SPACE-padded string
                case 'c':     // signed char
                case 'C':     // unsigned char
                    result += repeater;
                    break;

                case 's':     // signed short (always 16 bit, machine byte order)
                case 'S':     // unsigned short (always 16 bit, machine byte order)
                case 'n':     // unsigned short (always 16 bit, big endian byte order)
                case 'v':     // unsigned short (always 16 bit, little endian byte order)
                    result += repeater * 2;
                    break;

                case 'i':     // signed integer (machine dependent size and byte order - always 32 bit)
                case 'I':     // unsigned integer (machine dependent size and byte order - always 32 bit)
                case 'l':     // signed long (always 32 bit, machine byte order)
                case 'L':     // unsigned long (always 32 bit, machine byte order)
                case 'N':     // unsigned long (always 32 bit, big endian byte order)
                case 'V':     // unsigned long (always 32 bit, little endian byte order)
                case 'f':     // float (machine dependent size and representation)
                    result += repeater * 4;
                    break;

                case 'd':     // double (machine dependent size and representation)
                    result += repeater * 8;
                    break;

                case 'h':     // Hex string, low/high nibble first - converts to a string, takes n hex digits from it:
                case 'H':
                    result += (repeater + 1) / 2;
                    break;

                default:
                    Debug.Fail("Invalid repeater");
                    break;
                }

                // checks for overflow:
                if (result > Int32.MaxValue)
                {
                    PhpException.Throw(PhpError.Warning, LibResources.GetString("binary_data_overflown", specifier));
                    result = Int32.MaxValue;
                }

                // expands the max length:
                if (result > maxLength)
                {
                    maxLength = unchecked ((int)result);
                }
            }

            resultLength = unchecked ((int)result);
        }
Example #12
0
        protected virtual PhpDbResult ExecuteCommandInternal(string /*!*/ commandText, CommandType commandType, bool convertTypes, IEnumerable <IDataParameter> parameters, bool skipResults)
        {
            ClosePendingReader();

            // IDbCommand
            IDbCommand command = CreateCommand();

            command.Connection  = connection;
            command.CommandText = commandText;
            command.CommandType = commandType;

            if (parameters != null)
            {
                command.Parameters.Clear();
                foreach (IDataParameter parameter in parameters)
                {
                    command.Parameters.Add(parameter);
                }
            }

            // ExecuteReader
            PhpDbResult result = null;

            try
            {
                var /*!*/ reader = this.pendingReader = command.ExecuteReader();

                if (skipResults)
                {
                    // reads all data:
                    do
                    {
                        while (reader.Read())
                        {
                            ;
                        }
                    } while (reader.NextResult());
                }
                else
                {
                    lastResult = null;

                    // read all data into PhpDbResult:
                    result         = GetResult(this, reader, convertTypes);
                    result.command = command;

                    lastResult = result;
                }

                lastException = null;
            }
            catch (Exception e)
            {
                lastException = e;
                PhpException.Throw(PhpError.Warning, LibResources.GetString("command_execution_failed",
                                                                            GetExceptionMessage(e)));
            }

            //
            return(result);
        }
Example #13
0
 /// <summary>
 /// Serializes null and throws an exception.
 /// </summary>
 /// <param name="TypeName"></param>
 private object BindUnsupported(string TypeName)
 {
     PhpException.Throw(PhpError.Warning, LibResources.GetString("serialization_unsupported_type", TypeName));
     return(null);
 }
Example #14
0
        /// <summary>
        /// Executes a command on the connection.
        /// </summary>
        /// <param name="commandText">Command text.</param>
        /// <param name="convertTypes">Whether to convert data types to PHP ones.</param>
        /// <param name="commandType">Command type.</param>
        /// <param name="parameters">Parameters.</param>
        /// <param name="skipResults">Whether to load results.</param>
        /// <returns>PhpDbResult class representing the data read from database.</returns>
        /// <exception cref="ArgumentNullException"><paramref name="commandText"/> is a <B>null</B> reference.</exception>
        /// <exception cref="PhpException">Command execution failed (Warning).</exception>
        public PhpDbResult ExecuteCommand(string /*!*/ commandText, CommandType commandType, bool convertTypes,
                                          IEnumerable <IDataParameter> parameters, bool skipResults)
        {
            if (commandText == null)
            {
                throw new ArgumentNullException("commandText");
            }

            if (!Connect())
            {
                return(null);
            }

            ClosePendingReader();

            IDbCommand command = CreateCommand();

            command.Connection  = connection;
            command.CommandText = commandText;
            command.CommandType = commandType;

            if (parameters != null)
            {
                command.Parameters.Clear();
                foreach (IDataParameter parameter in parameters)
                {
                    command.Parameters.Add(parameter);
                }
            }

            try
            {
                if (skipResults)
                {
                    pendingReader = command.ExecuteReader();

                    // reads all data:
                    do
                    {
                        while (pendingReader.Read())
                        {
                            ;
                        }
                    } while (pendingReader.NextResult());

                    lastException = null;
                    return(null);
                }
                else
                {
                    lastResult = null;

                    pendingReader = command.ExecuteReader();
                    PhpDbResult result = GetResult(this, pendingReader, convertTypes);
                    result.command = command;

                    lastException = null;
                    lastResult    = result;
                    return(result);
                }
            }
            catch (Exception e)
            {
                lastException = e;
                PhpException.Throw(PhpError.Warning, LibResources.GetString("command_execution_failed",
                                                                            GetExceptionMessage(e)));
                return(null);
            }
        }