public static void AddParameter(this System.Data.IDbCommand command, object value)
{
var parameter = command.CreateParameter();
parameter.Value = value;
command.Parameters.Add(parameter);
}
/// <summary>
/// 创建DbCommand参数。
/// </summary>
/// <param name="dbCommand">DbCommand对象。</param>
/// <param name="commandParameter">命令参数对象。</param>
/// <returns>返回ADO.NET命令参数对象。</returns>
protected virtual System.Data.IDbDataParameter CreateDbCommandParameter(System.Data.IDbCommand dbCommand, CommandParameter commandParameter)
{
var result = dbCommand.CreateParameter();
if (commandParameter.IsReturn)
{
result.Direction = ParameterDirection.ReturnValue;
}
else
{
result.ParameterName = commandParameter.Name;
if (commandParameter.IsOut)
{
result.Direction = ParameterDirection.Output;
}
if (commandParameter.Value == null)
{
result.Value = System.DBNull.Value;
goto lb_Properties;
}
if (commandParameter.RealType.IsArray && commandParameter.RealType.GetElementType() == typeof(byte))
{
result.DbType = DbType.Binary;
result.Value = commandParameter.Value;
goto lb_Properties;
}
result.Value = commandParameter.Value;
}
lb_Properties:
foreach (System.Collections.Generic.KeyValuePair <string, object> p in commandParameter.Properties)
{
FastWrapper.Set(result, p.Key, p.Value);
}
return(result);
}
protected override void SetParameters(System.Data.IDbCommand command)
{
base.SetParameters(command);
_insertedIdentityParameter = command.CreateParameter();
_insertedIdentityParameter.ParameterName = "@InsertedIdentity";
_insertedIdentityParameter.Direction = ParameterDirection.Output;
_insertedIdentityParameter.DbType = DbType.Int32;
command.Parameters.Add(_insertedIdentityParameter);
}
protected virtual void GetEntityDeleteParameter(System.Data.IDbCommand CM, BaseEntitie ent)
{
ColumnCollection _column = ent.Column;
for (int i = 0; i < _column.Count; i++)
{
System.Data.IDbDataParameter sParameter = CM.CreateParameter();
sParameter.ParameterName = _column[i].FieldName;
sParameter.Value = _column[i].FieldValue;
sParameter.DbType = _column[i].FieldType;
CM.Parameters.Add(sParameter);
}
}
private System.Data.IDbCommand GetDbCommand(ISqlMapper sqlMapper, string statementName, StrObjectDict paramObject, StrObjectDict dictParam, System.Collections.Generic.IDictionary <string, System.Data.ParameterDirection> dictParmDirection, System.Data.CommandType cmdType)
{
System.Data.IDbCommand result;
if (cmdType == System.Data.CommandType.Text)
{
result = this.GetDbCommand(sqlMapper, statementName, paramObject);
}
else
{
IStatement statement = sqlMapper.GetMappedStatement(statementName).Statement;
IMappedStatement mappedStatement = sqlMapper.GetMappedStatement(statementName);
ISqlMapSession sqlMapSession = new SqlMapSession(sqlMapper);
if (sqlMapper.LocalSession != null)
{
sqlMapSession = sqlMapper.LocalSession;
}
else
{
sqlMapSession = sqlMapper.OpenConnection();
}
RequestScope requestScope = statement.Sql.GetRequestScope(mappedStatement, paramObject, sqlMapSession);
mappedStatement.PreparedCommand.Create(requestScope, sqlMapSession, statement, paramObject);
System.Data.IDbCommand dbCommand = sqlMapSession.CreateCommand(cmdType);
dbCommand.CommandText = requestScope.IDbCommand.CommandText;
if (cmdType != System.Data.CommandType.StoredProcedure || dictParam == null)
{
result = dbCommand;
}
else
{
foreach (System.Collections.Generic.KeyValuePair <string, object> current in dictParam)
{
string text = current.Key.ToString();
System.Data.IDbDataParameter dbDataParameter = dbCommand.CreateParameter();
dbDataParameter.ParameterName = text;
dbDataParameter.Value = current.Value;
if (dictParmDirection != null && dictParmDirection.ContainsKey(text))
{
dbDataParameter.Direction = dictParmDirection[text];
}
dbCommand.Parameters.Add(dbDataParameter);
}
result = dbCommand;
}
}
return(result);
}
public static bool AddParameters(System.Data.IDbCommand command, System.Collections.Generic.Dictionary <string, object> parametersToAdd)
{
if (command == null || parametersToAdd == null || parametersToAdd.Count == 0)
{
return(false);
}
foreach (KeyValuePair <string, object> param in parametersToAdd)
{
var parameter = command.CreateParameter();
parameter.ParameterName = param.Key;
parameter.DbType = getDbType(param.Value);
parameter.Value = (param.Value == null ? DBNull.Value : param.Value);
command.Parameters.Add(parameter);
}
return(true);
}
protected virtual void InitCommandSetParameter(QueryContext query, System.Data.IDbCommand cmd, string parametername, object parameterValue)
{
IDataParameter sqlparam = null;
//sqlparam = ConnectorTools.AddDataParameterWithValue(cmd, "@" + fieldKey, obj); //NpgsqlCommand cmd = conn.CreateCommand();
sqlparam = cmd.CreateParameter();
sqlparam.ParameterName = "@" + parametername;
sqlparam.Value = parameterValue;
// Détection du type
if (ConnectorTools.FindEngine(this.EngineName) == ConnectorConstants.ConnectorEngineEnum.POSTGRESQL)
{
// !!! A revoir
//https://github.com/npgsql/Npgsql/issues/177
if (parameterValue != null && parameterValue != DBNull.Value && parameterValue is string && ((string)parameterValue).StartsWith("<?xml", StringComparison.OrdinalIgnoreCase))
{
sqlparam.DbType = DbType.Xml;
}
}
cmd.Parameters.Add(sqlparam);
}
public void BuildCommandWithParameters(System.Data.IDbCommand command, bool append, string query, object[] par, bool isRaw)
{
if (append)
{
if (command.CommandText == null)
{
command.CommandText = "";
}
else if (command.CommandText.Length > 0)
{
command.CommandText += ";\n";
}
}
else
{
command.CommandText = "";
command.Parameters.Clear();
}
System.Text.StringBuilder sb = new System.Text.StringBuilder(query.Length * 2);
StringCollection paramNames = new StringCollection();
for (int i = 0; i < query.Length; ++i)
{
char c = query[i];
if (c == '\'')
{
int j = ++i;
for (;; ++j)
{
if (j >= query.Length)
{
throw new ArgumentException("Query has unbalanced quotes");
}
if (query[j] == '\'')
{
if (j + 1 >= query.Length || query[j + 1] != '\'')
{
break;
}
// double apostrophe
j++;
}
}
string stringValue = query.Substring(i, j - i);
char modifier = j + 1 < query.Length ? query[j + 1] : ' ';
string paramName;
switch (modifier)
{
case 'V':
sb.Append('\'');
sb.Append(stringValue);
sb.Append('\'');
j++;
break;
case 'D':
paramName = AddParameterFromValue(command, DateTime.ParseExact(stringValue, "yyyyMMddHH:mm:ss", CultureInfo.InvariantCulture), null);
sb.Append(paramName);
j++;
break;
case 'A':
stringValue = stringValue.Replace("''", "'");
paramName = AddParameterFromValue(command, stringValue, SoqlLiteralValueModifiers.AnsiString);
sb.Append(paramName);
j++;
break;
default:
if (!isRaw && (!UseSafeLiterals || !IsStringSafeForLiteral(stringValue)))
{
stringValue = stringValue.Replace("''", "'");
paramName = AddParameterFromValue(command, stringValue, null);
sb.Append(paramName);
}
else
{
sb.Append('\'');
sb.Append(stringValue);
sb.Append('\'');
}
break;
}
i = j;
}
else if (c == '{')
{
c = query[i + 1];
if (c == 'L')
{
// {L:fieldDataTypeName:value
int startPos = i + 3;
int endPos = query.IndexOf(':', startPos);
if (endPos < 0)
{
throw new ArgumentException("Missing ':' in literal specification");
}
SoqlLiteralValueModifiers modifier = SoqlParser.ParseLiteralValueModifiers(query.Substring(startPos, endPos - startPos));
FieldDataType fdt = modifier.DataTypeOverride;
int valueStartPos = endPos + 1;
bool anyEscape = false;
for (i = valueStartPos; i < query.Length && query[i] != '}'; ++i)
{
if (query[i] == '\\')
{
i++;
anyEscape = true;
}
}
string literalValue = query.Substring(valueStartPos, i - valueStartPos);
if (anyEscape)
{
literalValue = literalValue.Replace("\\}", "}");
literalValue = literalValue.Replace("\\\\", "\\");
}
SoodaFieldHandler fieldHandler = FieldHandlerFactory.GetFieldHandler(fdt);
object v = fieldHandler.RawDeserialize(literalValue);
if (v == null)
{
sb.Append("null");
}
else if (UseSafeLiterals && v is int)
{
sb.Append((int)v);
}
else if (UseSafeLiterals && v is string && IsStringSafeForLiteral((string)v))
{
sb.Append('\'');
sb.Append((string)v);
sb.Append('\'');
}
else
{
IDbDataParameter p = command.CreateParameter();
p.Direction = ParameterDirection.Input;
p.ParameterName = GetNameForParameter(command.Parameters.Count);
fieldHandler.SetupDBParameter(p, v);
command.Parameters.Add(p);
sb.Append(p.ParameterName);
}
}
else if (c >= '0' && c <= '9')
{
i++;
int paramNumber = 0;
do
{
paramNumber = paramNumber * 10 + c - '0';
c = query[++i];
} while (c >= '0' && c <= '9');
SoqlLiteralValueModifiers modifiers = null;
if (c == ':')
{
int startPos = i + 1;
i = query.IndexOf('}', startPos);
if (i < 0)
{
throw new ArgumentException("Missing '}' in parameter specification");
}
modifiers = SoqlParser.ParseLiteralValueModifiers(query.Substring(startPos, i - startPos));
}
else if (c != '}')
{
throw new ArgumentException("Missing '}' in parameter specification");
}
object v = par[paramNumber];
if (v is SoodaObject)
{
v = ((SoodaObject)v).GetPrimaryKeyValue();
}
if (v == null)
{
sb.Append("null");
}
else if (UseSafeLiterals && v is int)
{
sb.Append((int)v);
}
else if (UseSafeLiterals && v is string && IsStringSafeForLiteral((string)v))
{
sb.Append('\'');
sb.Append((string)v);
sb.Append('\'');
}
else
{
sb.Append(AddNumberedParameter(command, v, modifiers, paramNames, paramNumber));
}
}
else
{
throw new ArgumentException("Unexpected character in parameter specification");
}
}
else if (c == '(' || c == ' ' || c == ',' || c == '=' || c == '>' || c == '<' || c == '+' || c == '-' || c == '*' || c == '/')
{
sb.Append(c);
if (i < query.Length - 1)
{
c = query[i + 1];
if (c >= '0' && c <= '9' && !UseSafeLiterals)
{
int v = 0;
double f = 0;
double dp = 0;
bool isDouble = false;
do
{
if (c != '.')
{
if (!isDouble)
{
v = v * 10 + c - '0';
}
else
{
f = f + dp * (c - '0');
dp = dp * 0.1;
}
}
else
{
isDouble = true;
f = v;
dp = 0.1;
}
i++;
if (i < query.Length - 1)
{
c = query[i + 1];
}
} while (((c >= '0' && c <= '9') || c == '.') && (i < query.Length - 1));
if (!isDouble)
{
string paramName = AddParameterFromValue(command, v, null);
sb.Append(paramName);
}
else
{
string paramName = AddParameterFromValue(command, f, null);
sb.Append(paramName);
}
}
}
}
else
{
sb.Append(c);
}
}
command.CommandText += sb.ToString();
}
