Example #1
0
        /// <summary>
        /// Execute the test case represented by the object, and store execution results and/or outcome.
        /// </summary>
        public override void Execute()
        {
            // User supplied parameters will override internal parameters
            Boolean containsLiterals = ContainsLiterals.HasValue && ContainsLiterals.Value ||
                                       InternalParam.ContainsLiterals.HasValue && InternalParam.ContainsLiterals.Value && !ContainsLiterals.HasValue;
            Boolean singleObjectProj = SingleObjectProjection.HasValue && SingleObjectProjection.Value ||
                                       InternalParam.SingleObjectProjection.HasValue && InternalParam.SingleObjectProjection.Value && !SingleObjectProjection.HasValue;

            SqlEnumerator <dynamic> resultEnumerator = null;

            try
            {
                if (!InternalParam.ContainsLiterals.HasValue && !ContainsLiterals.HasValue)
                {
                    try
                    {
                        resultEnumerator = Db.SQL(Statement, Values).GetEnumerator() as SqlEnumerator <dynamic>;
                        InternalParam.ContainsLiterals = false;
                    }
                    catch (SqlException e)
                    {
                        throw e;
                    }
                    catch (Exception e) // Catches ScErrUnsupportLiteral error
                    {
                        //Console.WriteLine("Execute statement: " + e.Message);
                        // TODO: Match unsupported literal exception, throw otherwise.
                        //       Also removes the need for the SqlException above
                        resultEnumerator = Db.SlowSQL(Statement, Values).GetEnumerator() as SqlEnumerator <dynamic>;
                        InternalParam.ContainsLiterals = true;
                    }
                }
                else if (containsLiterals)
                {
                    resultEnumerator = Db.SlowSQL(Statement, Values).GetEnumerator() as SqlEnumerator <dynamic>;
                }
                else
                {
                    resultEnumerator = Db.SQL(Statement, Values).GetEnumerator() as SqlEnumerator <dynamic>;
                }

                string result;
                if (!InternalParam.SingleObjectProjection.HasValue && !SingleObjectProjection.HasValue)
                {
                    try
                    {
                        result = Utilities.GetResults(resultEnumerator, hasOrderByClause());
                        InternalParam.SingleObjectProjection = false;
                    }
                    catch (NullReferenceException e) // Exception indicating that the result set contains single element rows
                    {
                        //Console.WriteLine("GetResults: " + e.Message);
                        result = Utilities.GetSingleElementResults(resultEnumerator, hasOrderByClause());
                        InternalParam.SingleObjectProjection = true;
                    }
                }
                else if (singleObjectProj)
                {
                    result = Utilities.GetSingleElementResults(resultEnumerator, hasOrderByClause());
                }
                else
                {
                    result = Utilities.GetResults(resultEnumerator, hasOrderByClause());
                }

                ActualResults.Add(result);
                ActualExecutionPlan.Add(resultEnumerator.ToString());
                ActuallyUsesBisonParser.Add(resultEnumerator.IsBisonParserUsed);
            }
            catch (Exception exception) // Catch actual exceptions when executing queries
            {
                //Console.WriteLine("Actual exception: " + exception.Message);
                String exceptionMessage = exception.Message;
                if (exceptionMessage.Contains("\r"))
                {
                    exceptionMessage = exceptionMessage.Substring(0, exceptionMessage.IndexOf("\r"));
                }
                if (exceptionMessage.Contains("\n"))
                {
                    exceptionMessage = exceptionMessage.Substring(0, exceptionMessage.IndexOf("\n"));
                }

                ActualException.Add(exceptionMessage);
            }

            finally
            {
                if (resultEnumerator != null)
                {
                    resultEnumerator.Dispose();
                }
            }
        }
Example #2
0
        // TODO: Null checks and specify formats.
        /// <summary>
        /// Extracts a string representation of the results of an SQL query
        /// </summary>
        /// <param name="resultSet">The result of an SQL statement execution</param>
        /// <param name="usesOrderBy">A boolean indicating the use of the ORDER BY keyword in the query</param>
        /// <returns>A string representation of the results contained in the input SqlEnumerator</returns>
        public static string GetSingleElementResults(SqlEnumerator <dynamic> resultSet, Boolean usesOrderBy)
        {
            DbTypeCode    typeCode;
            List <String> result    = new List <String>();
            string        headerRow = separator + " " + resultSet.ProjectionTypeCode + " " + separator;
            string        row;

            // Extract values
            while (resultSet.MoveNext())
            {
                row      = separator + " ";
                typeCode = (DbTypeCode)resultSet.ProjectionTypeCode;

                switch (typeCode)
                {
                case DbTypeCode.Binary:
                    row += (Nullable <Binary>)resultSet.Current;
                    break;

                case DbTypeCode.Boolean:
                    row += (Nullable <Boolean>)resultSet.Current;
                    break;

                case DbTypeCode.Byte:
                    row += (Nullable <Byte>)resultSet.Current;
                    break;

                case DbTypeCode.DateTime:
                    row += (Nullable <DateTime>)resultSet.Current;
                    break;

                case DbTypeCode.Decimal:
                    row += (Nullable <Decimal>)resultSet.Current;
                    break;

                case DbTypeCode.Double:
                    row += (Nullable <Double>)resultSet.Current;
                    break;

                case DbTypeCode.Int16:
                    row += (Nullable <Int16>)resultSet.Current;
                    break;

                case DbTypeCode.Int32:
                    row += (Nullable <Int32>)resultSet.Current;
                    break;

                case DbTypeCode.Int64:
                    row += (Nullable <Int64>)resultSet.Current;
                    break;

                case DbTypeCode.Object:
                    row += (IObjectView)resultSet.Current;
                    break;

                case DbTypeCode.SByte:
                    row += (Nullable <SByte>)resultSet.Current;
                    break;

                case DbTypeCode.Single:
                    row += (Nullable <Single>)resultSet.Current;
                    break;

                case DbTypeCode.String:
                    row += (String)resultSet.Current;
                    break;

                case DbTypeCode.UInt16:
                    row += (Nullable <UInt16>)resultSet.Current;
                    break;

                case DbTypeCode.UInt32:
                    row += (Nullable <UInt32>)resultSet.Current;
                    break;

                case DbTypeCode.UInt64:
                    row += (Nullable <UInt64>)resultSet.Current;
                    break;

                default:
                    throw new ArgumentException("Invalid typeCode in result set");
                }
                row += " " + separator;
                result.Add(row);
            }
            return(GetResultString(headerRow, result, usesOrderBy));
        }
Example #3
0
        // TODO: Null checks and specify formats.
        /// <summary>
        /// Extracts a string representation of the results of an SQL query. Works with single object projection results
        /// </summary>
        /// <param name="resultSet">The result of an SQL statement execution</param>
        /// <param name="usesOrderBy">A boolean indicating the use of the ORDER BY keyword in the query</param>
        /// <returns>A string representation of the results contained in the input SqlEnumerator</returns>
        public static string GetResults(SqlEnumerator <dynamic> resultSet, Boolean usesOrderBy)
        {
            ITypeBinding     typeBind;
            IPropertyBinding propBind;
            List <String>    result = new List <string>();
            StringBuilder    header = new StringBuilder();
            StringBuilder    row    = new StringBuilder();

            // Extract column names and types
            typeBind = resultSet.TypeBinding;
            for (int i = 0; i < typeBind.PropertyCount; i++)
            {
                propBind = typeBind.GetPropertyBinding(i);
                header.Append(separator + " " + propBind.Name + ":" + propBind.TypeCode.ToString() + " ");
            }
            header.Append(separator);

            // Extract values
            while (resultSet.MoveNext())
            {
                row.Clear();
                typeBind = resultSet.TypeBinding;
                for (int i = 0; i < typeBind.PropertyCount; i++)
                {
                    row.Append(separator + " ");
                    propBind = typeBind.GetPropertyBinding(i);
                    switch (propBind.TypeCode)
                    {
                    case DbTypeCode.Binary:
                        row.Append(resultSet.Current.GetBinary(i));
                        break;

                    case DbTypeCode.Boolean:
                        row.Append(resultSet.Current.GetBoolean(i));
                        break;

                    case DbTypeCode.Byte:
                        row.Append(resultSet.Current.GetByte(i));
                        break;

                    case DbTypeCode.DateTime:
                        row.Append(resultSet.Current.GetDateTime(i));
                        break;

                    case DbTypeCode.Decimal:
                        row.Append(resultSet.Current.GetDecimal(i));
                        break;

                    case DbTypeCode.Double:
                        row.Append(resultSet.Current.GetDouble(i));
                        break;

                    case DbTypeCode.Int16:
                        row.Append(resultSet.Current.GetInt16(i));
                        break;

                    case DbTypeCode.Int32:
                        row.Append(resultSet.Current.GetInt32(i));
                        break;

                    case DbTypeCode.Int64:
                        row.Append(resultSet.Current.GetInt64(i));
                        break;

                    case DbTypeCode.Object:
                        row.Append(resultSet.Current.GetObject(i));
                        break;

                    case DbTypeCode.SByte:
                        row.Append(resultSet.Current.GetSByte(i));
                        break;

                    case DbTypeCode.Single:
                        row.Append(resultSet.Current.GetSingle(i));
                        break;

                    case DbTypeCode.String:
                        row.Append(resultSet.Current.GetString(i));
                        break;

                    case DbTypeCode.UInt16:
                        row.Append(resultSet.Current.GetUInt16(i));
                        break;

                    case DbTypeCode.UInt32:
                        row.Append(resultSet.Current.GetUInt32(i));
                        break;

                    case DbTypeCode.UInt64:
                        row.Append(resultSet.Current.GetUInt64(i));
                        break;

                    default:
                        throw new ArgumentException("Invalid typeCode in result set");
                    }
                    row.Append(" ");
                }
                row.Append(separator);
                result.Add(row.ToString());
            }
            return(GetResultString(header.ToString(), result, usesOrderBy));
        }
 private static void ResultLoop(SqlEnumerator<IObjectView> sqlEnum)
 {
     IObjectView obj = null;
     while (sqlEnum.MoveNext())
     {
         obj = sqlEnum.Current;
     }
 }
        private static List<String> CreateResultSingleton(SqlEnumerator<dynamic> sqlEnum)
        {
            String result = headerFieldSeparator + sqlEnum.ProjectionTypeCode.ToString() + headerFieldSeparator;
            List<String> resultList = new List<String>();
            String strValue = null;

            resultList.Add(result);

            while (sqlEnum.MoveNext())
            {
                if (sqlEnum.ProjectionTypeCode == null)
                    throw new Exception("Incorrect Entity object. Maybe due to incorrect declaration \"SingleObjectProjection: True\".");
                strValue = Utilities.GetSingletonResult((DbTypeCode)sqlEnum.ProjectionTypeCode, sqlEnum.Current);
                result = Utilities.FieldSeparator + strValue + Utilities.FieldSeparator;
                resultList.Add(result);
            }

            return resultList;
        }
        private static List<String> CreateResultComposite(SqlEnumerator<dynamic> sqlEnum)
        {
            String result = headerFieldSeparator;
            List<String> resultList = new List<String>();
            ITypeBinding typeBind = sqlEnum.TypeBinding;
            IPropertyBinding propBind = null;

            for (Int32 i = 0; i < typeBind.PropertyCount; i++)
            {
                propBind = typeBind.GetPropertyBinding(i);
                result += propBind.Name + ":" + propBind.TypeCode.ToString() + headerFieldSeparator;
            }
            resultList.Add(result);

            while (sqlEnum.MoveNext())
            {
                if (sqlEnum.Current == null || sqlEnum.Current is IObjectProxy) // TODO:Ruslan
                    throw new Exception("Incorrect CompositeObject. Maybe due to incorrect declaration \"SingleObjectProjection: False\".");
                result = Utilities.CreateObjectString(typeBind, sqlEnum.Current);
                resultList.Add(result);
            }

            return resultList;
        }