private static string BuildInsertQuery(IStatement statement)
        {
            StringBuilder builder = new StringBuilder();
            Insert        insert  = (Insert)statement;
            int           count   = statement.ParameterMap.PropertiesList.Count;

            builder.Append("INSERT INTO " + insert.Generate.Table + " (");
            for (int i = 0; i < count; i++)
            {
                ParameterProperty property = statement.ParameterMap.PropertiesList[i];
                if (i < (count - 1))
                {
                    builder.Append("\t" + property.ColumnName + ",");
                }
                else
                {
                    builder.Append("\t" + property.ColumnName + "");
                }
            }
            builder.Append(") VALUES (");
            for (int j = 0; j < count; j++)
            {
                ParameterProperty property1 = statement.ParameterMap.PropertiesList[j];
                if (j < (count - 1))
                {
                    builder.Append("\t?,");
                }
                else
                {
                    builder.Append("\t?");
                }
            }
            builder.Append(")");
            return(builder.ToString());
        }
예제 #2
0
        private void CreateParameter(AnimationTreeParameter parameter)
        {
            string type = "float";

            if (parameter.Type == AnimationTreeParameterType.Integer)
            {
                type = "int";
            }

            string initialValue = parameter.DefaultValue.ToString();

            if (parameter.Type == AnimationTreeParameterType.Float)
            {
                initialValue += "f";
            }

            Variable v = new Variable(type, parameter.Name, initialValue);

            Add(v);

            ParameterProperty p = new ParameterProperty(type, parameter.Name, Variable.GetName(parameter.Name), _Tree)
            {
                Comment   = parameter.Comment,
                Modifier  = Modifiers.Public,
                SubMethod = SubMethod.None
            };

            Add(p);
        }
예제 #3
0
        /// <summary>Shows the Messaging application.</summary>
        public void Show()
        {
            if (!ChooserHelper.NavigationInProgressGuard(delegate
            {
                this.Show();
            }
                                                         ))
            {
                return;
            }
            ParameterPropertyBag parameterPropertyBag = new ParameterPropertyBag();
            string to = this.To;

            if (!string.IsNullOrEmpty(to))
            {
                ParameterProperty parameterProperty = parameterPropertyBag.CreateProperty("To");
                parameterProperty.StringValue = to;
            }
            string body = this.Body;

            if (!string.IsNullOrEmpty(body))
            {
                ParameterProperty parameterProperty2 = parameterPropertyBag.CreateProperty("Body");
                parameterProperty2.StringValue = body;
            }
            ParameterProperty parameterProperty3 = parameterPropertyBag.CreateProperty("Account");

            parameterProperty3.StringValue = "{FD39DA85-C18F-4c0c-AEAC-75867CEA7876}";
            Uri appUri = new Uri("app://5B04B775-356B-4AA0-AAF8-6491FFEA5614/ShareContent", UriKind.Absolute);

            ChooserHelper.Navigate(appUri, parameterPropertyBag);
        }
예제 #4
0
        private void EvaluateParameterMap()
        {
            string          delimiters    = "?";
            string          current       = null;
            int             num           = 0;
            string          parameterName = string.Empty;
            StringTokenizer tokenizer     = new StringTokenizer(this._commandText, delimiters, true);
            StringBuilder   builder       = new StringBuilder();
            IEnumerator     enumerator    = tokenizer.GetEnumerator();

            while (enumerator.MoveNext())
            {
                current = (string)enumerator.Current;
                if (delimiters.Equals(current))
                {
                    ParameterProperty property  = this._request.ParameterMap.Properties[num];
                    IDataParameter    parameter = null;
                    if (this._session.DataSource.DbProvider.UsePositionalParameters)
                    {
                        if (this._parameterPrefix.Equals(":"))
                        {
                            parameterName = ":" + num;
                        }
                        else
                        {
                            parameterName = "?";
                        }
                    }
                    else
                    {
                        parameter = (IDataParameter)this._propertyDbParameterMap[property];
                        if (this._session.DataSource.DbProvider.UseParameterPrefixInParameter)
                        {
                            if (this._session.DataSource.DbProvider.Name.IndexOf("ByteFx") >= 0)
                            {
                                parameterName = this._parameterPrefix + parameter.ParameterName;
                            }
                            else
                            {
                                parameterName = parameter.ParameterName;
                            }
                        }
                        else
                        {
                            parameterName = this._parameterPrefix + parameter.ParameterName;
                        }
                    }
                    builder.Append(" ");
                    builder.Append(parameterName);
                    parameterName = string.Empty;
                    num++;
                }
                else
                {
                    builder.Append(current);
                }
            }
            this._preparedStatement.PreparedSql = builder.ToString();
        }
예제 #5
0
 public override object GetData(ParameterProperty mapping, object parameterObject)
 {
     if (!mapping.IsComplexMemberName && (this._parameterClass == parameterObject.GetType()))
     {
         return(mapping.GetAccessor.Get(parameterObject));
     }
     return(ObjectProbe.GetMemberValue(parameterObject, mapping.PropertyName, base.DataExchangeFactory.AccessorFactory));
 }
 public override object GetData(ParameterProperty mapping, object parameterObject)
 {
     if (mapping.IsComplexMemberName)
     {
         return(ObjectProbe.GetMemberValue(parameterObject, mapping.PropertyName, base.DataExchangeFactory.AccessorFactory));
     }
     return(parameterObject);
 }
예제 #7
0
        /// <summary>
        /// Creates an select SQL command text for a specified statement
        /// </summary>
        /// <param name="statement">The statement to build the SQL command text.</param>
        /// <returns>The SQL command text for the statement.</returns>
        private static string BuildSelectQuery(IStatement statement)
        {
            StringBuilder output      = new StringBuilder();
            Select        select      = (Select)statement;
            int           columnCount = statement.ParameterMap.PropertiesList.Count;

            output.Append("SELECT ");

            // Create the list of columns
            for (int i = 0; i < columnCount; i++)
            {
                ParameterProperty property = (ParameterProperty)statement.ParameterMap.PropertiesList[i];

                if (i < (columnCount - 1))
                {
                    output.Append("\t" + property.ColumnName + " as " + property.PropertyName + ",");
                }
                else
                {
                    output.Append("\t" + property.ColumnName + " as " + property.PropertyName);
                }
            }

            output.Append(" FROM ");
            output.Append("\t" + select.Generate.Table + "");

            // Create the where clause

            string [] compositeKeyList = select.Generate.By.Split(new Char [] { ',' });
            if (compositeKeyList.Length > 0 && select.Generate.By.Length > 0)
            {
                output.Append(" WHERE ");
                int length = compositeKeyList.Length;
                for (int i = 0; i < length; i++)
                {
                    string columnName = compositeKeyList[i];

                    if (i > 0)
                    {
                        output.Append("\tAND " + columnName + " = ?");
                    }
                    else
                    {
                        output.Append("\t" + columnName + " = ?");
                    }
                }
            }

            // 'Select All' case
            if (statement.ParameterClass == null)
            {
                // The ParameterMap is just used to build the query
                // to avoid problems later, we set it to null
                statement.ParameterMap = null;
            }

            return(output.ToString());
        }
예제 #8
0
        private void CreateParametersForTextCommand()
        {
            string str = string.Empty;
            string parameterDbTypeProperty         = this._session.DataSource.DbProvider.ParameterDbTypeProperty;
            Type   parameterDbType                 = this._session.DataSource.DbProvider.ParameterDbType;
            ParameterPropertyCollection properties = null;

            if (this._session.DataSource.DbProvider.UsePositionalParameters)
            {
                properties = this._request.ParameterMap.Properties;
            }
            else
            {
                properties = this._request.ParameterMap.PropertiesList;
            }
            this._preparedStatement.DbParameters = new IDbDataParameter[properties.Count];
            for (int i = 0; i < properties.Count; i++)
            {
                ParameterProperty key = properties[i];
                if (this._session.DataSource.DbProvider.UseParameterPrefixInParameter)
                {
                    str = this._parameterPrefix + "param" + i;
                }
                else
                {
                    str = "param" + i;
                }
                IDbDataParameter parameter = this._session.CreateDataParameter();
                if ((key.DbType != null) && (key.DbType.Length > 0))
                {
                    object memberValue = Enum.Parse(parameterDbType, key.DbType, true);
                    ObjectProbe.SetMemberValue(parameter, parameterDbTypeProperty, memberValue, this._request.DataExchangeFactory.ObjectFactory, this._request.DataExchangeFactory.AccessorFactory);
                }
                if (this._session.DataSource.DbProvider.SetDbParameterSize && (key.Size != -1))
                {
                    parameter.Size = key.Size;
                }
                if (this._session.DataSource.DbProvider.SetDbParameterPrecision)
                {
                    parameter.Precision = key.Precision;
                }
                if (this._session.DataSource.DbProvider.SetDbParameterScale)
                {
                    parameter.Scale = key.Scale;
                }
                parameter.Direction     = key.Direction;
                parameter.ParameterName = str;
                this._preparedStatement.DbParametersName.Add(key.PropertyName);
                this._preparedStatement.DbParameters[i] = parameter;
                if (!this._session.DataSource.DbProvider.UsePositionalParameters)
                {
                    this._propertyDbParameterMap.Add(key, parameter);
                }
            }
        }
예제 #9
0
 public override void SetData(ref object target, ParameterProperty mapping, object dataBaseValue)
 {
     if (mapping.IsComplexMemberName)
     {
         ObjectProbe.SetMemberValue(target, mapping.PropertyName, dataBaseValue, base.DataExchangeFactory.ObjectFactory, base.DataExchangeFactory.AccessorFactory);
     }
     else
     {
         base.DataExchangeFactory.AccessorFactory.SetAccessorFactory.CreateSetAccessor(this._parameterClass, mapping.PropertyName).Set(target, dataBaseValue);
     }
 }
예제 #10
0
 private void RetrieveOutputParameters(RequestScope request, ISqlMapSession session, IDbCommand command, object result)
 {
     if (request.ParameterMap != null)
     {
         int count = request.ParameterMap.PropertiesList.Count;
         for (int i = 0; i < count; i++)
         {
             ParameterProperty mapping = request.ParameterMap.GetProperty(i);
             if ((mapping.Direction == ParameterDirection.Output) || (mapping.Direction == ParameterDirection.InputOutput))
             {
                 string columnName = string.Empty;
                 if (!session.DataSource.DbProvider.UseParameterPrefixInParameter)
                 {
                     columnName = mapping.ColumnName;
                 }
                 else
                 {
                     columnName = session.DataSource.DbProvider.ParameterPrefix + mapping.ColumnName;
                 }
                 if (mapping.TypeHandler == null)
                 {
                     lock (mapping)
                     {
                         if (mapping.TypeHandler == null)
                         {
                             Type memberTypeForGetter = ObjectProbe.GetMemberTypeForGetter(result, mapping.PropertyName);
                             mapping.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(memberTypeForGetter);
                         }
                     }
                 }
                 IDataParameter parameter     = (IDataParameter)command.Parameters[columnName];
                 object         obj2          = parameter.Value;
                 object         dataBaseValue = null;
                 if (obj2 == DBNull.Value)
                 {
                     if (mapping.HasNullValue)
                     {
                         dataBaseValue = mapping.TypeHandler.ValueOf(mapping.GetAccessor.MemberType, mapping.NullValue);
                     }
                     else
                     {
                         dataBaseValue = mapping.TypeHandler.NullValue;
                     }
                 }
                 else
                 {
                     dataBaseValue = mapping.TypeHandler.GetDataBaseValue(parameter.Value, result.GetType());
                 }
                 request.IsRowDataFound = request.IsRowDataFound || (dataBaseValue != null);
                 request.ParameterMap.SetOutputParameter(ref result, mapping, dataBaseValue);
             }
         }
     }
 }
예제 #11
0
 /// <summary>
 /// Gets the data to be set into a IDataParameter.
 /// </summary>
 /// <param name="mapping"></param>
 /// <param name="parameterObject"></param>
 public override object GetData(ParameterProperty mapping, object parameterObject)
 {
     if (parameterObject != null)
     {
         if (DataExchangeFactory.TypeHandlerFactory.IsSimpleType(parameterObject.GetType()))
         {
             return(parameterObject);
         }
         return(ObjectProbe.GetMemberValue(parameterObject, mapping.PropertyName, DataExchangeFactory.AccessorFactory));
     }
     return(null);
 }
예제 #12
0
        /// <summary>
        /// Creates an update SQL command text for a specified statement
        /// </summary>
        /// <param name="statement">The statement to build the SQL command text.</param>
        /// <returns>The SQL command text for the statement.</returns>
        private static string BuildUpdateQuery(IStatement statement)
        {
            StringBuilder output      = new StringBuilder();
            Update        update      = (Update)statement;
            int           columnCount = statement.ParameterMap.PropertiesList.Count;

            string[] keysList = update.Generate.By.Split(',');

            output.Append("UPDATE ");
            output.Append("\t" + update.Generate.Table + " ");
            output.Append("SET ");

            // Create the set statement
            for (int i = 0; i < columnCount; i++)
            {
                ParameterProperty property = (ParameterProperty)statement.ParameterMap.PropertiesList[i];

                // Ignore key columns
                if (update.Generate.By.IndexOf(property.ColumnName) < 0)
                {
                    if (i < (columnCount - keysList.Length - 1))
                    {
                        output.Append("\t" + property.ColumnName + " = ?,");
                    }
                    else
                    {
                        output.Append("\t" + property.ColumnName + " = ? ");
                    }
                }
            }

            output.Append(" WHERE ");

            // Create the where clause
            int length = keysList.Length;

            for (int i = 0; i < length; i++)
            {
                string columnName = keysList[i];

                if (i > 0)
                {
                    output.Append("\tAND " + columnName + " = ?");
                }
                else
                {
                    output.Append("\t " + columnName + " = ?");
                }
            }

            return(output.ToString());
        }
예제 #13
0
        /// <summary>
        /// Creates an insert SQL command text for a specified statement
        /// </summary>
        /// <param name="statement">The statement to build the SQL command text.</param>
        /// <returns>The SQL command text for the statement.</returns>
        private static string BuildInsertQuery(IStatement statement)
        {
            StringBuilder output      = new StringBuilder();
            Insert        insert      = (Insert)statement;
            int           columnCount = statement.ParameterMap.PropertiesList.Count;

            output.Append("INSERT INTO " + insert.Generate.Table + " (");

            // Create the parameter list
            for (int i = 0; i < columnCount; i++)
            {
                ParameterProperty property = (ParameterProperty)statement.ParameterMap.PropertiesList[i];

                // Append the column name as a parameter of the insert statement
                if (i < (columnCount - 1))
                {
                    output.Append("\t" + property.ColumnName + ",");
                }
                else
                {
                    output.Append("\t" + property.ColumnName + "");
                }
            }

            output.Append(") VALUES (");

            // Create the values list
            for (int i = 0; i < columnCount; i++)
            {
                ParameterProperty property = (ParameterProperty)statement.ParameterMap.PropertiesList[i];

                // Append the necessary line breaks and commas
                if (i < (columnCount - 1))
                {
                    output.Append("\t?,");
                }
                else
                {
                    output.Append("\t?");
                }
            }

            output.Append(")");

            return(output.ToString());
        }
        private static string BuildSelectQuery(IStatement statement)
        {
            StringBuilder builder = new StringBuilder();
            Select        select  = (Select)statement;
            int           count   = statement.ParameterMap.PropertiesList.Count;

            builder.Append("SELECT ");
            for (int i = 0; i < count; i++)
            {
                ParameterProperty property = statement.ParameterMap.PropertiesList[i];
                if (i < (count - 1))
                {
                    builder.Append("\t" + property.ColumnName + " as " + property.PropertyName + ",");
                }
                else
                {
                    builder.Append("\t" + property.ColumnName + " as " + property.PropertyName);
                }
            }
            builder.Append(" FROM ");
            builder.Append("\t" + select.Generate.Table + "");
            string[] strArray = select.Generate.By.Split(new char[] { ',' });
            if ((strArray.Length > 0) && (select.Generate.By.Length > 0))
            {
                builder.Append(" WHERE ");
                int length = strArray.Length;
                for (int j = 0; j < length; j++)
                {
                    string str = strArray[j];
                    if (j > 0)
                    {
                        builder.Append("\tAND " + str + " = ?");
                    }
                    else
                    {
                        builder.Append("\t" + str + " = ?");
                    }
                }
            }
            if (statement.ParameterClass == null)
            {
                statement.ParameterMap = null;
            }
            return(builder.ToString());
        }
예제 #15
0
        /// <summary>Shows the Web Search application.</summary>
        public void Show()
        {
            if (!ChooserHelper.NavigationInProgressGuard(delegate
            {
                this.Show();
            }
                                                         ))
            {
                return;
            }
            ParameterPropertyBag parameterPropertyBag = new ParameterPropertyBag();
            ParameterProperty    parameterProperty    = parameterPropertyBag.CreateProperty("QueryString");

            parameterProperty.StringValue = this.SearchQuery;
            Uri appUri = new Uri("app://5B04B775-356B-4AA0-AAF8-6491FFEA5661/SearchResults", UriKind.Absolute);

            ChooserHelper.Navigate(appUri, parameterPropertyBag);
        }
        public static ParameterProperty Deserialize(XmlNode node, ConfigurationScope configScope)
        {
            ParameterProperty   property   = new ParameterProperty();
            NameValueCollection attributes = NodeUtils.ParseAttributes(node, configScope.Properties);

            configScope.ErrorContext.MoreInfo = "ParameterPropertyDeSerializer";
            property.CallBackName             = NodeUtils.GetStringAttribute(attributes, "typeHandler");
            property.CLRType            = NodeUtils.GetStringAttribute(attributes, "type");
            property.ColumnName         = NodeUtils.GetStringAttribute(attributes, "column");
            property.DbType             = NodeUtils.GetStringAttribute(attributes, "dbType", null);
            property.DirectionAttribute = NodeUtils.GetStringAttribute(attributes, "direction");
            property.NullValue          = attributes["nullValue"];
            property.PropertyName       = NodeUtils.GetStringAttribute(attributes, "property");
            property.Precision          = NodeUtils.GetByteAttribute(attributes, "precision", 0);
            property.Scale = NodeUtils.GetByteAttribute(attributes, "scale", 0);
            property.Size  = NodeUtils.GetIntAttribute(attributes, "size", -1);
            return(property);
        }
        private static string BuildUpdateQuery(IStatement statement)
        {
            StringBuilder builder = new StringBuilder();
            Update        update  = (Update)statement;
            int           count   = statement.ParameterMap.PropertiesList.Count;

            string[] strArray = update.Generate.By.Split(new char[] { ',' });
            builder.Append("UPDATE ");
            builder.Append("\t" + update.Generate.Table + " ");
            builder.Append("SET ");
            for (int i = 0; i < count; i++)
            {
                ParameterProperty property = statement.ParameterMap.PropertiesList[i];
                if (update.Generate.By.IndexOf(property.ColumnName) < 0)
                {
                    if (i < ((count - strArray.Length) - 1))
                    {
                        builder.Append("\t" + property.ColumnName + " = ?,");
                    }
                    else
                    {
                        builder.Append("\t" + property.ColumnName + " = ? ");
                    }
                }
            }
            builder.Append(" WHERE ");
            int length = strArray.Length;

            for (int j = 0; j < length; j++)
            {
                string str = strArray[j];
                if (j > 0)
                {
                    builder.Append("\tAND " + str + " = ?");
                }
                else
                {
                    builder.Append("\t " + str + " = ?");
                }
            }
            return(builder.ToString());
        }
예제 #18
0
        /// <summary>
        /// Builds the parameter properties.
        /// </summary>
        /// <param name="parameterMap">The parameter map.</param>
        /// <param name="parameterMapConfig">The parameter map config.</param>
        private void BuildParameterProperties(ParameterMap parameterMap, IConfiguration parameterMapConfig)
        {
            ConfigurationCollection parametersConfig = parameterMapConfig.Children.Find(ConfigConstants.ELEMENT_PARAMETER);

            for (int i = 0; i < parametersConfig.Count; i++)
            {
                IConfiguration    parameterConfig = parametersConfig[i];
                ParameterProperty property        = null;
                try
                {
                    property = ParameterPropertyDeSerializer.Deserialize(modelStore.DataExchangeFactory, parameterMap.Class,
                                                                         parameterConfig);
                }
                catch (Exception e)
                {
                    throw new DataMapperException("In ParameterMap (" + parameterMap.Id + ") can't build the parameter property: " + ConfigurationUtils.GetStringAttribute(parameterConfig.Attributes, ConfigConstants.ATTRIBUTE_PROPERTY) + ". Cause " + e.Message, e);
                }
                parameterMap.AddParameterProperty(property);
            }
        }
예제 #19
0
        /// <summary>Shows the contacts application.</summary>
        public override void Show()
        {
            if (!ChooserHelper.NavigationInProgressGuard(delegate
            {
                this.Show();
            }
                                                         ))
            {
                return;
            }
            ParameterPropertyBag parameterPropertyBag = new ParameterPropertyBag();
            ParameterProperty    parameterProperty    = parameterPropertyBag.CreateProperty("PhoneNumberToSave");

            parameterProperty.StringValue = this.PhoneNumber;
            byte[] buffer = ChooserHelper.Serialize(parameterPropertyBag);
            Uri    appUri = new Uri("app://5B04B775-356B-4AA0-AAF8-6491FFEA5615/SaveANumberToAddressBook", UriKind.Absolute);

            base.Show();
            ChooserHelper.Invoke(appUri, buffer, this._genericChooser);
        }
예제 #20
0
        internal override void OnInvokeReturned(byte[] outputBuffer, Delegate fireThisHandlerOnly)
        {
            bool flag = false;

            if (outputBuffer.Length > 0)
            {
                ParameterPropertyBag parameterPropertyBag = new ParameterPropertyBag(outputBuffer, (uint)outputBuffer.Length);
                ParameterProperty    property             = parameterPropertyBag.GetProperty("SelectedFilePath");
                if (property.ValueType == ParameterPropertyValueType.ValueType_String && !string.IsNullOrEmpty(property.StringValue))
                {
                    flag = true;
                    PhotoResult photoResult = ChooserHelper.PathParameterToPhotoResult(property);
                    photoResult.TaskResult = TaskResult.OK;
                    base.FireCompleted(this, photoResult, fireThisHandlerOnly);
                }
            }
            if (!flag)
            {
                base.FireCompleted(this, new PhotoResult(TaskResult.Cancel), fireThisHandlerOnly);
            }
        }
예제 #21
0
        internal override void OnInvokeReturned(byte[] outputBuffer, Delegate fireThisHandlerOnly)
        {
            bool flag = false;

            if (outputBuffer.Length > 0)
            {
                ParameterPropertyBag parameterPropertyBag = new ParameterPropertyBag(outputBuffer, (uint)outputBuffer.Length);
                ParameterProperty    property             = parameterPropertyBag.GetProperty("PickerPropertyValue");
                if (property.ValueType == ParameterPropertyValueType.ValueType_String && !string.IsNullOrEmpty(property.StringValue))
                {
                    flag = true;
                    base.FireCompleted(this, new PhoneNumberResult(TaskResult.OK)
                    {
                        PhoneNumber = property.StringValue
                    }, fireThisHandlerOnly);
                }
            }
            if (!flag)
            {
                base.FireCompleted(this, new PhoneNumberResult(TaskResult.Cancel), fireThisHandlerOnly);
            }
        }
예제 #22
0
 private IDbDataParameter Search(IDbDataParameter[] parameters, ParameterProperty property, int index)
 {
     if (property.ColumnName.Length > 0)
     {
         for (int i = 0; i < parameters.Length; i++)
         {
             string parameterName = parameters[i].ParameterName;
             if (dbProvider.UseParameterPrefixInParameter)
             {
                 if (parameterName.StartsWith(dbProvider.ParameterPrefix))
                 {
                     int prefixLength = dbProvider.ParameterPrefix.Length;
                     parameterName = parameterName.Substring(prefixLength);
                 }
             }
             if (property.ColumnName.Equals(parameterName))
             {
                 return(parameters[i]);
             }
         }
         throw new IndexOutOfRangeException("The parameter '" + property.ColumnName + "' does not exist in the stored procedure '" + statement.Id + "'. Check your parameterMap.");
     }
     return(parameters[index]);
 }
 /// <summary>
 /// Sets the value to the parameter property.
 /// </summary>
 /// <remarks>Use to set value on output parameter</remarks>
 /// <param name="mapping"></param>
 /// <param name="target"></param>
 /// <param name="dataBaseValue"></param>
 public override void SetData(ref object target, ParameterProperty mapping, object dataBaseValue)
 {
     ObjectProbe.SetMemberValue(target, mapping.PropertyName, dataBaseValue,
                                this.DataExchangeFactory.ObjectFactory,
                                this.DataExchangeFactory.AccessorFactory);
 }
예제 #24
0
        /// <summary>
        /// Retrieve the output parameter and map them on the result object.
        /// This routine is only use is you specified a ParameterMap and some output attribute
        /// or if you use a store procedure with output parameter...
        /// </summary>
        /// <param name="request"></param>
        /// <param name="session">The current session.</param>
        /// <param name="result">The result object.</param>
        /// <param name="command">The command sql.</param>
        private static void RetrieveOutputParameters(RequestScope request, ISession session, IDbCommand command, object result)
        {
            if (request.ParameterMap != null && request.ParameterMap.HasOutputParameter)
            {
                int count = request.ParameterMap.PropertiesList.Count;
                for (int i = 0; i < count; i++)
                {
                    ParameterProperty mapping = request.ParameterMap.GetProperty(i);
                    if (mapping.Direction == ParameterDirection.Output ||
                        mapping.Direction == ParameterDirection.InputOutput)
                    {
                        string parameterName = string.Empty;
                        if (session.SessionFactory.DataSource.DbProvider.UseParameterPrefixInParameter == false)
                        {
                            parameterName = mapping.ColumnName;
                        }
                        else
                        {
                            parameterName = session.SessionFactory.DataSource.DbProvider.ParameterPrefix +
                                            mapping.ColumnName;
                        }

                        if (mapping.TypeHandler == null) // Find the TypeHandler
                        {
                            lock (mapping)
                            {
                                if (mapping.TypeHandler == null)
                                {
                                    Type propertyType = ObjectProbe.GetMemberTypeForGetter(result, mapping.PropertyName);

                                    mapping.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(propertyType);
                                }
                            }
                        }

                        // Fix IBATISNET-239
                        //"Normalize" System.DBNull parameters
                        IDataParameter dataParameter = (IDataParameter)command.Parameters[parameterName];
                        object         dbValue       = dataParameter.Value;

                        object value = null;

                        bool wasNull = (dbValue == DBNull.Value);
                        if (wasNull)
                        {
                            if (mapping.HasNullValue)
                            {
                                value = mapping.TypeHandler.ValueOf(mapping.GetAccessor.MemberType, mapping.NullValue);
                            }
                            else
                            {
                                value = mapping.TypeHandler.NullValue;
                            }
                        }
                        else
                        {
                            value = mapping.TypeHandler.GetDataBaseValue(dataParameter.Value, result.GetType());
                        }

                        request.IsRowDataFound = request.IsRowDataFound || (value != null);

                        request.ParameterMap.SetOutputParameter(ref result, mapping, value);
                    }
                }
            }
        }
        /// <summary>
        /// Parse sql command text.
        /// </summary>
        private void EvaluateParameterMap()
        {
            string          delimiter            = "?";
            string          token                = null;
            int             index                = 0;
            string          sqlParamName         = string.Empty;
            StringTokenizer parser               = new StringTokenizer(_commandText, delimiter, true);
            StringBuilder   newCommandTextBuffer = new StringBuilder();

            IEnumerator enumerator = parser.GetEnumerator();

            while (enumerator.MoveNext())
            {
                token = (string)enumerator.Current;

                if (delimiter.Equals(token))                 // ?
                {
                    ParameterProperty property      = _request.ParameterMap.Properties[index];
                    IDataParameter    dataParameter = null;

                    if (_session.DataSource.DbProvider.UsePositionalParameters)
                    {
                        // TODO Refactor?
                        if (_parameterPrefix.Equals(":"))
                        {
                            // ODP.NET uses positional parameters by default
                            // but uses ":0" or ":1" instead of "?"
                            sqlParamName = ":" + index;
                        }
                        else
                        {
                            // OLEDB/OBDC doesn't support named parameters !!!
                            sqlParamName = "?";
                        }
                    }
                    else
                    {
                        dataParameter = (IDataParameter)_propertyDbParameterMap[property];

                        // 5 May 2004
                        // Need to check UseParameterPrefixInParameter here
                        // since CreateParametersForStatementText now does
                        // a check for UseParameterPrefixInParameter before
                        // creating the parameter name!
                        if (_session.DataSource.DbProvider.UseParameterPrefixInParameter)
                        {
                            // Fix ByteFX.Data.MySqlClient.MySqlParameter
                            // who strip prefix in Parameter Name ?!
                            if (_session.DataSource.DbProvider.Name.IndexOf("ByteFx") >= 0)
                            {
                                sqlParamName = _parameterPrefix + dataParameter.ParameterName;
                            }
                            else
                            {
                                sqlParamName = dataParameter.ParameterName;
                            }
                        }
                        else
                        {
                            sqlParamName = _parameterPrefix + dataParameter.ParameterName;
                        }
                    }

                    newCommandTextBuffer.Append(" ");
                    newCommandTextBuffer.Append(sqlParamName);

                    sqlParamName = string.Empty;
                    index++;
                }
                else
                {
                    newCommandTextBuffer.Append(token);
                }
            }

            _preparedStatement.PreparedSql = newCommandTextBuffer.ToString();
        }
        /// <summary>
        /// Create IDataParameters for procedure statement.
        /// </summary>
        private void CreateParametersForProcedureCommand()
        {
            string sqlParamName              = string.Empty;
            string dbTypePropertyName        = _session.DataSource.DbProvider.ParameterDbTypeProperty;
            Type   enumDbType                = _session.DataSource.DbProvider.ParameterDbType;
            ParameterPropertyCollection list = null;

            if (_session.DataSource.DbProvider.UsePositionalParameters)             //obdc/oledb
            {
                list = _request.ParameterMap.Properties;
            }
            else
            {
                list = _request.ParameterMap.PropertiesList;
            }

            _preparedStatement.DbParameters = new IDbDataParameter[list.Count];

            // ParemeterMap are required for procedure and we tested existance in Prepare() method
            // so we don't have to test existence here.
            // A ParameterMap used in CreateParametersForProcedureText must
            // have property and column attributes set.
            // The column attribute is the name of a procedure parameter.
            for (int i = 0; i < list.Count; i++)
            {
                ParameterProperty property = list[i];

                if (_session.DataSource.DbProvider.UseParameterPrefixInParameter)
                {
                    sqlParamName = _parameterPrefix + property.ColumnName;
                }
                else                 //obdc/oledb
                {
                    sqlParamName = property.ColumnName;
                }

                IDbDataParameter dataParameter = _session.CreateCommand(_statement.CommandType).CreateParameter();

                // Manage dbType attribute if any
                if (property.DbType != null && property.DbType.Length > 0)
                {
                    // Exemple : Enum.parse(System.Data.SqlDbType, 'VarChar')
                    object dbType = Enum.Parse(enumDbType, property.DbType, true);

                    // Exemple : ObjectHelper.SetProperty(sqlparameter, 'SqlDbType', SqlDbType.Int);
                    ObjectProbe.SetMemberValue(dataParameter, dbTypePropertyName, dbType,
                                               _request.DataExchangeFactory.ObjectFactory,
                                               _request.DataExchangeFactory.AccessorFactory);
                }

                // Set IDbDataParameter
                // JIRA-49 Fixes (size, precision, and scale)
                if (_session.DataSource.DbProvider.SetDbParameterSize)
                {
                    if (property.Size != -1)
                    {
                        dataParameter.Size = property.Size;
                    }
                }

                if (_session.DataSource.DbProvider.SetDbParameterPrecision)
                {
                    dataParameter.Precision = property.Precision;
                }

                if (_session.DataSource.DbProvider.SetDbParameterScale)
                {
                    dataParameter.Scale = property.Scale;
                }

                // Set as direction parameter
                dataParameter.Direction = property.Direction;

                dataParameter.ParameterName = sqlParamName;

                _preparedStatement.DbParametersName.Add(property.PropertyName);
                _preparedStatement.DbParameters[i] = dataParameter;

                if (_session.DataSource.DbProvider.UsePositionalParameters == false)
                {
                    _propertyDbParameterMap.Add(property, dataParameter);
                }
            }
        }
        /// <summary>
        /// Create IDataParameters for command text statement.
        /// </summary>
        private void CreateParametersForTextCommand()
        {
            string sqlParamName              = string.Empty;
            string dbTypePropertyName        = _session.DataSource.DbProvider.ParameterDbTypeProperty;
            Type   enumDbType                = _session.DataSource.DbProvider.ParameterDbType;
            ParameterPropertyCollection list = null;

            if (_session.DataSource.DbProvider.UsePositionalParameters)             //obdc/oledb
            {
                list = _request.ParameterMap.Properties;
            }
            else
            {
                list = _request.ParameterMap.PropertiesList;
            }

            _preparedStatement.DbParameters = new IDbDataParameter[list.Count];

            for (int i = 0; i < list.Count; i++)
            {
                ParameterProperty property = list[i];

                if (_session.DataSource.DbProvider.UseParameterPrefixInParameter)
                {
                    // From Ryan Yao: JIRA-27, used "param" + i++ for sqlParamName
                    sqlParamName = _parameterPrefix + "param" + i;
                }
                else
                {
                    sqlParamName = "param" + i;
                }

                IDbDataParameter dataParameter = _session.CreateDataParameter();

                // Manage dbType attribute if any
                if (property.DbType != null && property.DbType.Length > 0)
                {
                    // Exemple : Enum.parse(System.Data.SqlDbType, 'VarChar')
                    object dbType = Enum.Parse(enumDbType, property.DbType, true);

                    // Exemple : ObjectHelper.SetProperty(sqlparameter, 'SqlDbType', SqlDbType.Int);
                    ObjectProbe.SetMemberValue(dataParameter, dbTypePropertyName, dbType,
                                               _request.DataExchangeFactory.ObjectFactory,
                                               _request.DataExchangeFactory.AccessorFactory);
                }

                // Set IDbDataParameter
                // JIRA-49 Fixes (size, precision, and scale)
                if (_session.DataSource.DbProvider.SetDbParameterSize)
                {
                    if (property.Size != -1)
                    {
                        dataParameter.Size = property.Size;
                    }
                }

                if (_session.DataSource.DbProvider.SetDbParameterPrecision)
                {
                    dataParameter.Precision = property.Precision;
                }

                if (_session.DataSource.DbProvider.SetDbParameterScale)
                {
                    dataParameter.Scale = property.Scale;
                }

                // Set as direction parameter
                dataParameter.Direction = property.Direction;

                dataParameter.ParameterName = sqlParamName;

                _preparedStatement.DbParametersName.Add(property.PropertyName);
                _preparedStatement.DbParameters[i] = dataParameter;

                if (_session.DataSource.DbProvider.UsePositionalParameters == false)
                {
                    _propertyDbParameterMap.Add(property, dataParameter);
                }
            }
        }
 public void AddParameterMapping(ParameterProperty mapping)
 {
     this._parameterMappings.Add(mapping);
 }
예제 #29
0
        /// <summary>
        /// Applies the parameter map.
        /// </summary>
        /// <param name="session">The session.</param>
        /// <param name="command">The command.</param>
        /// <param name="request">The request.</param>
        /// <param name="statement">The statement.</param>
        /// <param name="parameterObject">The parameter object.</param>
        protected virtual void ApplyParameterMap
            (ISqlMapSession session, IDbCommand command,
            RequestScope request, IStatement statement, object parameterObject)
        {
            StringCollection properties = request.PreparedStatement.DbParametersName;

            IDbDataParameter[] parameters   = request.PreparedStatement.DbParameters;
            StringBuilder      paramLogList = new StringBuilder(); // Log info
            StringBuilder      typeLogList  = new StringBuilder(); // Log info

            int count = properties.Count;

            for (int i = 0; i < count; ++i)
            {
                IDbDataParameter  sqlParameter  = parameters[i];
                IDbDataParameter  parameterCopy = command.CreateParameter();
                ParameterProperty property      = request.ParameterMap.GetProperty(i);

                if (command.CommandType == CommandType.StoredProcedure)
                {
                    #region store procedure command

                    // A store procedure must always use a ParameterMap
                    // to indicate the mapping order of the properties to the columns
                    if (request.ParameterMap == null)                     // Inline Parameters
                    {
                        throw new DataMapperException("A procedure statement tag must alway have a parameterMap attribute, which is not the case for the procedure '" + statement.Id + "'.");
                    }
                    else                     // Parameters via ParameterMap
                    {
                        if (property.DirectionAttribute.Length == 0)
                        {
                            property.Direction = sqlParameter.Direction;
                        }

                        sqlParameter.Direction = property.Direction;
                    }
                    #endregion
                }

                request.ParameterMap.SetParameter(property, parameterCopy, parameterObject);

                parameterCopy.Direction = sqlParameter.Direction;

                // With a ParameterMap, we could specify the ParameterDbTypeProperty
                if (request.ParameterMap != null)
                {
                    if (property.DbType != null && property.DbType.Length > 0)
                    {
                        string dbTypePropertyName = session.DataSource.DbProvider.ParameterDbTypeProperty;
                        object propertyValue      = ObjectProbe.GetMemberValue(sqlParameter, dbTypePropertyName, request.DataExchangeFactory.AccessorFactory);
                        ObjectProbe.SetMemberValue(parameterCopy, dbTypePropertyName, propertyValue,
                                                   request.DataExchangeFactory.ObjectFactory, request.DataExchangeFactory.AccessorFactory);
                    }
                    else
                    {
                        //parameterCopy.DbType = sqlParameter.DbType;
                    }
                }
                else
                {
                    //parameterCopy.DbType = sqlParameter.DbType;
                }


                // JIRA-49 Fixes (size, precision, and scale)
                if (session.DataSource.DbProvider.SetDbParameterSize)
                {
                    if (sqlParameter.Size > 0)
                    {
                        parameterCopy.Size = sqlParameter.Size;
                    }
                }

                if (session.DataSource.DbProvider.SetDbParameterPrecision)
                {
                    parameterCopy.Precision = sqlParameter.Precision;
                }

                if (session.DataSource.DbProvider.SetDbParameterScale)
                {
                    parameterCopy.Scale = sqlParameter.Scale;
                }

                parameterCopy.ParameterName = sqlParameter.ParameterName;

                command.Parameters.Add(parameterCopy);
            }
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="session"></param>
        /// <param name="command"></param>
        /// <param name="request"></param>
        /// <param name="statement"></param>
        /// <param name="parameterObject"></param>
        protected override void ApplyParameterMap
            (IDalSession session, IDbCommand command,
            RequestScope request, IStatement statement, object parameterObject)
        {
            ArrayList properties     = request.PreparedStatement.DbParametersName;
            ArrayList parameters     = request.PreparedStatement.DbParameters;
            object    parameterValue = null;

            int count = properties.Count;

            for (int i = 0; i < count; ++i)
            {
                IDataParameter sqlParameter = (IDataParameter)parameters[i];
                string         propertyName = (string)properties[i];

                if (command.CommandType == CommandType.Text)
                {
                    if (propertyName != "value")                     // Inline Parameters && Parameters via ParameterMap
                    {
//						ParameterProperty property = request.ParameterMap.GetProperty(i);

//						parameterValue = request.ParameterMap.GetValueOfProperty(parameterObject,
//							property.PropertyName);
                    }
                    else                     // 'value' parameter
                    {
                        parameterValue = parameterObject;
                    }
                }
                else                 // CommandType.StoredProcedure
                {
                    // A store procedure must always use a ParameterMap
                    // to indicate the mapping order of the properties to the columns
                    if (request.ParameterMap == null)                     // Inline Parameters
                    {
                        throw new DataMapperException("A procedure statement tag must alway have a parameterMap attribute, which is not the case for the procedure '" + statement.Id + "'.");
                    }
                    else                     // Parameters via ParameterMap
                    {
                        ParameterProperty property = request.ParameterMap.GetProperty(i);

                        if (property.DirectionAttribute.Length == 0)
                        {
                            property.Direction = sqlParameter.Direction;
                        }

                        //						IDbDataParameter dataParameter = (IDbDataParameter)parameters[i];
                        //						property.Precision = dataParameter.Precision;
                        //						property.Scale = dataParameter.Scale;
                        //						property.Size = dataParameter.Size;

                        sqlParameter.Direction = property.Direction;
//						parameterValue = request.ParameterMap.GetValueOfProperty(parameterObject, property.PropertyName);
                    }
                }

                IDataParameter parameterCopy = command.CreateParameter();
                // Fix JIRA 20
                sqlParameter.Value  = parameterValue;
                parameterCopy.Value = parameterValue;

                parameterCopy.Direction = sqlParameter.Direction;

                // With a ParameterMap, we could specify the ParameterDbTypeProperty
                if (statement.ParameterMap != null)
                {
                    if (request.ParameterMap.GetProperty(i).DbType != null &&
                        request.ParameterMap.GetProperty(i).DbType.Length > 0)
                    {
                        string dbTypePropertyName = session.DataSource.DbProvider.ParameterDbTypeProperty;

                        ObjectProbe.SetPropertyValue(parameterCopy, dbTypePropertyName, ObjectProbe.GetPropertyValue(sqlParameter, dbTypePropertyName));
                    }
                    else
                    {
                        //parameterCopy.DbType = sqlParameter.DbType;
                    }
                }
                else
                {
                    //parameterCopy.DbType = sqlParameter.DbType;
                }

                // JIRA-49 Fixes (size, precision, and scale)
                if (session.DataSource.DbProvider.SetDbParameterSize)
                {
                    if (((IDbDataParameter)sqlParameter).Size > 0)
                    {
                        ((IDbDataParameter)parameterCopy).Size = ((IDbDataParameter)sqlParameter).Size;
                    }
                }

                if (session.DataSource.DbProvider.SetDbParameterPrecision)
                {
                    ((IDbDataParameter)parameterCopy).Precision = ((IDbDataParameter)sqlParameter).Precision;
                }

                if (session.DataSource.DbProvider.SetDbParameterScale)
                {
                    ((IDbDataParameter)parameterCopy).Scale = ((IDbDataParameter)sqlParameter).Scale;
                }

                parameterCopy.ParameterName = sqlParameter.ParameterName;

                command.Parameters.Add(parameterCopy);


                // NOTE:
                // Code from Oleksa Borodie to embed parameter values
                // into command text/sql statement.
                // NEED TO MERGE WITH ABOVE AFTER INITIAL TESTING
                // TO REMOVE REDUNDANT LOOPING!

                // replace parameter names with parameter values
                // only for parameters with names, parameterMaps will be ignored
                IDataParameter p;
                for (int iCnt = command.Parameters.Count - 1; iCnt >= 0; iCnt--)
                {
                    p = (IDataParameter)command.Parameters[iCnt];
                    if (p.Direction == ParameterDirection.Input &&
                        command.CommandText.IndexOf(p.ParameterName) > 0)
                    {
                        switch (p.DbType)
                        {
                        case DbType.String:
                        case DbType.AnsiString:
                        case
                            DbType.AnsiStringFixedLength:
                        case DbType.StringFixedLength:
                            command.CommandText =
                                command.CommandText.Replace(p.ParameterName,
                                                            "\'" + p.Value.ToString().Replace("\'", "\'\'") + "\'");
                            break;

                        case DbType.Date:
                        case DbType.DateTime:
                            DateTime v =
                                Convert.ToDateTime(p.Value);
                            command.CommandText =
                                command.CommandText.Replace(p.ParameterName,
                                                            String.Format("\'{0}.{1}.{2} {3}:{4}:{5}.{6}\'", v.Year, v.Month,
                                                                          v.Day, v.Hour, v.Minute, v.Second, v.Millisecond));
                            //                                                      command.CommandText =
                            command.CommandText.Replace(p.ParameterName,
                                                        "\'" + p.Value.ToString() + "\'");
                            break;

                        case DbType.Double:
                        case DbType.Decimal:
                        case DbType.Currency:
                        case DbType.Single:
                            command.CommandText =
                                command.CommandText.Replace(p.ParameterName,
                                                            p.Value.ToString().Replace(',', '.'));
                            break;

                        default:
                            command.CommandText =
                                command.CommandText.Replace(p.ParameterName, p.Value.ToString());
                            break;
                        }
                        command.Parameters.RemoveAt(iCnt);
                    }
                }
            }
        }