CppSetRoutineParam.cs

Go to the documentation of this file.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace RoutineAnalyzer
{
    class CppSetRoutineParam : RoutineParamBase
    {
        #region Static Methods

        public static string GetCppGetOperation(ParameterTypes type)
        {
            switch (type)
            {
                case ParameterTypes.IntByReference: return "getInt";
                case ParameterTypes.StringByReference: return "getString";
                default: return "getInt";
            }
        }

        public static string GetCppSetOperation(ParameterTypes type)
        {
            switch (type)
            {
                case ParameterTypes.IntByValue: return "setInt";
                case ParameterTypes.StringByValue: return "setString";
                default: return "setInt";
            }
        }

        public static string GetCppWrapperType(ParameterTypes type)
        {
            switch (type)
            {
                case ParameterTypes.IntByReference: return "int*";
                case ParameterTypes.IntByValue: return "int";
                case ParameterTypes.StringByReference: return "std::string&";
                case ParameterTypes.StringByValue: return "const std::string&";

                default:
                    throw new Exception("Error: Cpp type not implemented!");
            }
        }

        #endregion

        public CppSetRoutineParam(string sql, int index)
            : base(sql, index)
        {
        }

        public override string GetDeclaration()
        {
            string cppType = GetCppWrapperType(_type);
            string cppName = ParseHelper.ConvertUnderscoreToCamelCase(Name);
            return string.Format("{0} {1}", cppType, cppName);
        }

        public override string GetPreExecuteCode()
        {
            //if this isn't an in param, then we do not perform a pre-execute work
            //our pre-execute setup is just sending in our named variable
            if (!_isInParam)
                return "";

            //If this is an IN paramter, then we have to set the value in the prepared statement
            //before execute is called.

            if (_type == ParameterTypes.StringByValue)
            {
                return string.Format("{0}->setString({1},{2});",
                                         ParseHelper.PreparedStmtName,
                                         _index + 1,   //MySQL library starts counting at 1
                                         ParseHelper.ConvertUnderscoreToCamelCase(Name));
            }
            else
            {
                string setOperation = GetCppSetOperation(_type);
                return string.Format("{0}->{1}({2},{3});",
                                         ParseHelper.PreparedStmtName,
                                         setOperation,
                                         _index + 1,   //MySQL library starts counting at 1
                                         ParseHelper.ConvertUnderscoreToCamelCase(Name));
            }

            throw new Exception("Error determining argument CPP code");
        }

        public override string GetPostExecuteCode()
        {
            //in parameters never have post execute code
            if (_isInParam)
                return "";

            //OUT parameters always have post execute code

            //the post execute code will query the database for the variable named
            //for this argument's ParamMarker.  It will traverse the result set
            //of this query, then 
            StringBuilder builder = new StringBuilder();

            //we create a new scope so we don't have name collisions amongst multiple out parameters
            builder.AppendLine("{");

            //use auto_ptr for all declarations in here so we don't lost anything
            builder.AppendLine("std::auto_ptr< sql::ResultSet > res;");
            //we create a whole new statement because the MySQL library doesn't like re-using the prepared statement used for the execute
            //In the future, it does seem like some performance gain could be had by eliminating making a whole new object (how much? who knows)
            builder.AppendLine("std::auto_ptr< sql::Statement > stmt;");
            builder.AppendLine("stmt.reset(connection->createStatement());");
            //we query out of the database the value of the variable we utilized during the execute (same name as our param marker)
            builder.AppendLine(string.Format("res.reset(stmt->executeQuery(\"SELECT {1} from dual\"));",
                                ParseHelper.PreparedStmtName, GetParameter()));
            builder.AppendLine("res->next();");
            string cppName = ParseHelper.ConvertUnderscoreToCamelCase(Name);
            string getOperation = GetCppGetOperation(_type);
            if (_type == ParameterTypes.IntByReference)
                builder.AppendLine(string.Format("*{0} = res->{1}(1);", cppName, getOperation));
            else if (_type == ParameterTypes.StringByReference)
                builder.AppendLine(string.Format("{0} = res->getString(1);"));
            else
                throw new Exception("Error, parameter type not implemented");

            //close the new scope
            builder.AppendLine("}");

            return builder.ToString();
        }
    }
}