protected internal virtual void OutputCommandInfo(IDbCommand cmd)
{
if (cmd == null)
{
throw new ArgumentNullException(nameof(cmd));
}
StringBuilder stringBuilder = new StringBuilder();
stringBuilder.AppendFormat("Output command infomation\r\n#output start\r\nText:\r\n{0}\r\n", (object)cmd.CommandText);
string[] array = cmd.CommandText.Split(new string[1]
{
" "
}, StringSplitOptions.RemoveEmptyEntries);
int num = Math.Max(Array.FindIndex <string>(array, (Predicate <string>)(cp => cp.ToLower() == "into")), Array.FindIndex <string>(array, (Predicate <string>)(cp => cp.ToLower() == "update")));
string s1 = string.Empty;
string str1 = string.Empty;
if (num >= 0)
{
int index = num + 1;
str1 = array[index].Replace("[", string.Empty).Replace("]", string.Empty);
}
if (cmd.Parameters.Count > 0)
{
stringBuilder.Append("Parameters:\r\n");
foreach (IDataParameter parameter in (IEnumerable)cmd.Parameters)
{
if (this.GetSize != null)
{
s1 = this.GetSize(str1, parameter.ParameterName);
}
int result1 = 0;
if (int.TryParse(s1, out result1) && parameter.Value.ToString().Length > result1)
{
string str2 = parameter.ParameterName.Replace("@", string.Empty);
this.truncatedColumns.Add(string.Format("The length of the data of {0}.{1} is {2} which exceeds the allowed size of {3}.", (object)str1, (object)str2, (object)parameter.Value.ToString().Length, (object)result1));
}
string str3 = !string.IsNullOrEmpty(s1) ? string.Format("(DB: {0}; Data: {1})", (object)s1, (object)parameter.Value.ToString().Length) : string.Empty;
stringBuilder.AppendFormat("{0}={1}\t{2}{3}\r\n", (object)parameter.ParameterName, parameter.Value, (object)parameter.DbType, (object)str3);
string s2 = parameter.Value == null ? string.Empty : parameter.Value.ToString().Trim();
Enums.ValueType valueType1 = this.GetColumnType(str1, parameter.ParameterName);
if (s2 != string.Empty && valueType1 != Enums.ValueType.Unknown)
{
double result2 = 0.0;
DateTime result3 = DateTime.MinValue;
string empty = string.Empty;
Enums.ValueType valueType2 = !double.TryParse(s2, out result2) ? (!DateTime.TryParse(s2, out result3) ? Enums.ValueType.String : Enums.ValueType.DateTime) : Enums.ValueType.Numeric;
string str2 = parameter.ParameterName.Replace("@", string.Empty);
if (valueType1 != valueType2 && valueType1 != Enums.ValueType.String)
{
this.wrongDataTypeColumns.Add(string.Format("The value {0} is type {1} which does not match the database type of {2} for {3}.{4}.", (object)s2, (object)valueType2.ToString(), (object)valueType1.ToString(), (object)str1, (object)str2));
}
stringBuilder.AppendFormat("{0}.{1} is {2}. Data is {3}", (object)str1, (object)str2, (object)valueType1.ToString(), (object)valueType2.ToString());
}
}
}
stringBuilder.AppendLine("#output end");
//GlobalTracer.TraceVerbose(stringBuilder.ToString(), string.Format("{0}.OutputCommandInfo", (object)"Utility4.Data.DbClient"));
}
protected static DataCollection.DataItem CreateItem(
string fieldID,
object fieldValue,
Enums.ValueType valueType)
{
return(new DataCollection.DataItem()
{
FieldID = fieldID,
Value = fieldValue,
ValueType = valueType
});
}
protected virtual DataCollection.DataItem CreateDataItem(string fieldID)
{
if (string.IsNullOrWhiteSpace(fieldID))
{
throw new ArgumentNullException(nameof(fieldID));
}
try
{
object dataItemValue = this.GetDataItemValue(fieldID);
Enums.ValueType valueType = this.GetValueTypeFunc == null?DataCollection.GetValueType(dataItemValue) : this.GetValueTypeFunc(fieldID);
return(DataCollection.CreateItem(fieldID, dataItemValue, valueType));
}
catch (Exception ex)
{
//if (!this.Silent)
// GlobalTracer.TraceWarningFormat("Create data item failed, field id:{0}, details:{1}", (object)fieldID, (object)ex.Message);
return((DataCollection.DataItem)null);
}
}
public void SetItem(string fieldID, object fieldValue, Enums.ValueType valueType)
{
if (string.IsNullOrWhiteSpace(fieldID))
{
throw new ArgumentNullException(nameof(fieldID));
}
//if (fieldID.StartsWith("$") && !this.Silent)
// GlobalTracer.TraceVerboseFormat("start to set system field, {0}:{1}", (object)fieldID, fieldValue);
if (this.pitems.ContainsKey(fieldID))
{
DataCollection.DataItem pitem = this.pitems[fieldID];
pitem.Value = fieldValue;
pitem.ValueType = valueType;
}
else
{
DataCollection.DataItem dataItem = DataCollection.CreateItem(fieldID, fieldValue, valueType);
this.pitems.Add(fieldID, dataItem);
}
}
/// <summary>
/// Indicates the type of value to be used for the property.
/// </summary>
/// <param name="type">The type of value to be used for the property.</param>
public ValueAttribute(Enums.ValueType type)
{
ValueType = type;
}
public ItemFilterEventArgs()
{
this.ValueType = Enums.ValueType.Unknown;
}
public static MappingDictionary ParseText(
Stream stream,
TextMappingParser parser)
{
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
if (parser == null)
{
throw new ArgumentNullException(nameof(parser));
}
DataSet dataSet = new DataSet();
StreamReader streamReader = new StreamReader(stream);
DataTable table = (DataTable)null;
try
{
while (!streamReader.EndOfStream)
{
string line = string.Format("{0}", (object)streamReader.ReadLine()).Trim();
if (!string.IsNullOrWhiteSpace(line))
{
string tableName;
if (parser.ParseTableName(line, out tableName))
{
table?.AcceptChanges();
if (dataSet.Tables.Contains(tableName))
{
throw new Exception(string.Format("Duplication table name:{0}.", (object)tableName));
}
table = parser.CreateSchema(tableName);
dataSet.Tables.Add(table);
}
else
{
if (table == null)
{
table = parser.CreateSchema(parser.DefaultTableName);
dataSet.Tables.Add(table);
}
DataRow row = table.NewRow();
Enums.ValueType valueType = parser.ParseTypeFunc == null ? Enums.ValueType.Unknown : parser.ParseTypeFunc(line);
object[] objArray = new object[4]
{
parser.DataColumnNameConvertFunc != null ? (object)parser.DataColumnNameConvertFunc(line) : (object)line,
(object)line,
(object)string.Format("[{0}]", (object)line),
(object)valueType.ToString()
};
row.ItemArray = objArray;
table.Rows.Add(row);
}
}
else
{
break;
}
}
table?.AcceptChanges();
dataSet.AcceptChanges();
}
finally
{
streamReader?.Close();
}
return(new MappingDictionary(parser.MappingConvertFunc, dataSet)
{
DataColumnConvertFunc = parser.DataColumnConvertFunc
});
}
public ValueTypeAttribute(Enums.ValueType valueType)
{
ValueType = valueType;
}