using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Reflection;

namespace AIMSExtension
{
	public class GPDbHelper
	{
		private GPDBConn _dbConn;

		private static DateTime expireTime;

		private static int differenceSeconds = 0;

		public GPDBConn DbConn
		{
			get
			{
				bool flag = this._dbConn == null;
				if (flag)
				{
					this._dbConn = new GPDBConn();
				}
				return this._dbConn;
			}
		}

		public bool CanOpen
		{
			get
			{
				bool result;
				try
				{
					result = this.DbConn.OpenConn(null);
				}
				catch (Exception)
				{
					result = false;
				}
				return result;
			}
		}

		public SqlConnection Connection
		{
			get
			{
				return this.DbConn.Connection;
			}
		}

		public SqlCommand Command
		{
			get
			{
				return this.DbConn.Command;
			}
		}

		public string StaticConnectionString
		{
			get
			{
				return this.DbConn.StaticConnectionString;
			}
			set
			{
				this.DbConn.StaticConnectionString = value;
			}
		}

		public int CommandTimeout
		{
			get
			{
				return this.DbConn.CommandTimeout;
			}
			set
			{
				this.DbConn.CommandTimeout = value;
			}
		}

		public DateTime DbServerTime
		{
			get
			{
				DateTime dateTime = DateTime.Now;
				bool flag = GPDbHelper.expireTime > dateTime;
				DateTime result;
				if (flag)
				{
					result = dateTime.AddSeconds((double)GPDbHelper.differenceSeconds);
				}
				else
				{
					try
					{
						object value = this.DbConn.ExecuteScalar("SELECT GETDATE()");
						DateTime dateTime2 = Convert.ToDateTime(value);
						GPDbHelper.differenceSeconds = Convert.ToInt32((dateTime2 - dateTime).TotalSeconds);
						GPDbHelper.expireTime = dateTime.AddSeconds(1800.0);
						dateTime = dateTime2;
					}
					catch (Exception)
					{
						dateTime = dateTime.AddSeconds((double)GPDbHelper.differenceSeconds);
					}
					result = dateTime;
				}
				return result;
			}
		}

		public GPDbHelper()
		{
			this._dbConn = new GPDBConn();
		}

		public GPDbHelper(string connectString)
		{
			this._dbConn = new GPDBConn(connectString);
		}

		public SqlCommand CreateCommand()
		{
			return this.DbConn.CreateCommand();
		}

		public bool OpenConn()
		{
			return this.DbConn.OpenConn(null);
		}

		public bool CloseConn()
		{
			return this.DbConn.CloseConn();
		}

		public SqlTransaction BeginTransaction()
		{
			return this.DbConn.BeginTransaction();
		}

		public bool Commit()
		{
			return this.DbConn.Commit();
		}

		public bool RollBack()
		{
			return this.DbConn.RollBack();
		}

		public int Execute(string sql)
		{
			return this.DbConn.Execute(sql);
		}

		public int Execute(string sql, SqlParameter[] parameters)
		{
			return this.Execute(sql, parameters);
		}

		public int Execute(List<string> list)
		{
			return this.DbConn.Execute(list);
		}

		public int Execute(string[] sqlArray)
		{
			return this.DbConn.Execute(sqlArray);
		}

		public object ExecuteScalar(string sql)
		{
			return this.DbConn.ExecuteScalar(sql);
		}

		public int GetInt(string sql)
		{
			object t = this.DbConn.ExecuteScalar(sql);
			return GPFunctions.CInt<object>(t);
		}

		public string GetString(string sql)
		{
			object t = this.DbConn.ExecuteScalar(sql);
			return GPFunctions.CStr<object>(t);
		}

		public decimal GetDecimal(string sql)
		{
			object t = this.DbConn.ExecuteScalar(sql);
			return GPFunctions.CDecimal<object>(t);
		}

		public double GetDouble(string sql)
		{
			object t = this.DbConn.ExecuteScalar(sql);
			return GPFunctions.CDbl<object>(t);
		}

		public DateTime GetDateTime(string sql)
		{
			object t = this.DbConn.ExecuteScalar(sql);
			return GPFunctions.CDate<object>(t);
		}

		public DataTable GetDataTable(string sql)
		{
			SqlCommand sqlCommand = this.CreateCommand();
			sqlCommand.CommandText = sql;
			return this.GetDataTable(sqlCommand);
		}

		public DataTable GetDataTable(SqlCommand cmd)
		{
			DataTable dataTable = new DataTable();
			this.OpenConn();
			new SqlDataAdapter
			{
				AcceptChangesDuringFill = true,
				SelectCommand = cmd
			}.Fill(dataTable);
			bool flag = !this.DbConn.IsTransaction;
			if (flag)
			{
				this.DbConn.CloseConn();
			}
			return dataTable;
		}

		public DataTable GetDataTableWithKey(string sql)
		{
			this.OpenConn();
			DataTable dataTable = new DataTable();
			SqlDataAdapter dataAdapter = this.DbConn.DataAdapter;
			dataAdapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
			dataAdapter.SelectCommand.CommandText = sql;
			dataAdapter.Fill(dataTable);
			bool flag = !this.DbConn.IsTransaction;
			if (flag)
			{
				this.DbConn.CloseConn();
			}
			return dataTable;
		}

		public DataTable GetDataTableWithKey(SqlCommand cmd)
		{
			this.OpenConn();
			DataTable dataTable = new DataTable();
			SqlDataAdapter dataAdapter = this.DbConn.DataAdapter;
			dataAdapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
			dataAdapter.SelectCommand = cmd;
			dataAdapter.Fill(dataTable);
			bool flag = !this.DbConn.IsTransaction;
			if (flag)
			{
				this.DbConn.CloseConn();
			}
			return dataTable;
		}

		public DataSet GetDataSet(string sql, string tableName = "")
		{
			this.OpenConn();
			DataSet dataSet = new DataSet();
			SqlDataAdapter dataAdapter = this.DbConn.DataAdapter;
			dataAdapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
			dataAdapter.SelectCommand.CommandText = sql;
			bool flag = tableName.Length > 0;
			if (flag)
			{
				dataAdapter.Fill(dataSet, tableName);
			}
			else
			{
				dataAdapter.Fill(dataSet);
			}
			bool flag2 = !this.DbConn.IsTransaction;
			if (flag2)
			{
				this.DbConn.CloseConn();
			}
			return dataSet;
		}

		public DataSet GetDataSet(SqlCommand cmd, string tableName)
		{
			DataSet dataSet = new DataSet();
			this.DbConn.OpenConn(cmd.Connection);
			SqlDataAdapter dataAdapter = this.DbConn.DataAdapter;
			dataAdapter.MissingSchemaAction = MissingSchemaAction.AddWithKey;
			dataAdapter.SelectCommand = cmd;
			bool flag = tableName.Length > 0;
			if (flag)
			{
				dataAdapter.Fill(dataSet, tableName);
			}
			else
			{
				dataAdapter.Fill(dataSet);
			}
			bool flag2 = !this.DbConn.IsTransaction;
			if (flag2)
			{
				this.DbConn.CloseConn();
			}
			return dataSet;
		}

		public DataSet GetDataSet(string[] sqlArray)
		{
			DataSet dataSet = new DataSet();
			int num = sqlArray.Length;
			bool flag = num == 0;
			if (flag)
			{
				throw new Exception("GetDataTables: no sql statement。");
			}
			bool flag2 = num == 1;
			DataSet result;
			if (flag2)
			{
				dataSet = this.GetDataSet(sqlArray[0], "");
				result = dataSet;
			}
			else
			{
				for (int i = 0; i < sqlArray.Length; i++)
				{
					string sql = sqlArray[i];
					DataTable dataTable = this.GetDataTable(sql);
					dataSet.Tables.Add(dataTable);
				}
				bool flag3 = !this.DbConn.IsTransaction;
				if (flag3)
				{
					this.DbConn.CloseConn();
				}
				result = dataSet;
			}
			return result;
		}

		public T GetEntity<T>(string sql) where T : new()
		{
			SqlCommand command = this.Command;
			command.CommandText = sql;
			return this.GetEntity<T>(command);
		}

		public T GetEntity<T>(SqlCommand cmd) where T : new()
		{
			this.OpenConn();
			T t = Activator.CreateInstance<T>();
			DataTable dataTable = this.GetDataTable(cmd);
			bool flag = dataTable.Rows.Count == 0;
			T result;
			if (flag)
			{
				result = t;
			}
			else
			{
				DataRow dataRow = dataTable.Rows[0];
				PropertyInfo[] properties = t.GetType().GetProperties(BindingFlags.Instance | BindingFlags.Public);
				PropertyInfo[] array = properties;
				for (int i = 0; i < array.Length; i++)
				{
					PropertyInfo propertyInfo = array[i];
					DataColumnCollection columns = dataTable.Columns;
					string name = propertyInfo.Name;
					int num = columns.IndexOf(name);
					bool flag2 = num >= 0 && dataRow[num] != DBNull.Value;
					if (flag2)
					{
						object value = dataRow[num];
						Type propertyType = propertyInfo.PropertyType;
						bool flag3 = propertyType.IsValueType && propertyType != columns[num].DataType;
						if (flag3)
						{
							value = Convert.ChangeType(value, propertyType);
						}
						propertyInfo.SetValue(t, value, null);
					}
				}
				result = t;
			}
			return result;
		}

		public List<T> GetList<T>(string sql) where T : new()
		{
			DataTable dataTable = this.GetDataTable(sql);
			return GPFunData.DataTableToList<T>(dataTable);
		}

		public List<T> GetList<T>(string sql, int timeoutSeconds) where T : new()
		{
			T t = Activator.CreateInstance<T>();
			int hashCode = (t.ToString() + sql).GetHashCode();
			bool flag = timeoutSeconds > 0;
			List<T> result;
			if (flag)
			{
				object cacheInfo = MyCache.GetCacheInfo(hashCode);
				bool flag2 = cacheInfo != null;
				if (flag2)
				{
					result = (List<T>)cacheInfo;
					return result;
				}
			}
			else
			{
				MyCache.Remove(hashCode);
			}
			List<T> list = this.GetList<T>(sql);
			MyCache.SetCacheInfo(hashCode, list, timeoutSeconds);
			result = list;
			return result;
		}

		public List<T> GetList<T>(SqlCommand cmd) where T : new()
		{
			DataTable dataTable = this.GetDataTable(cmd);
			return GPFunData.DataTableToList<T>(dataTable);
		}

		public int DataTableSave(DataTable dataTable, string IduSQLRuleText, bool isAdapter = false)
		{
			this.OpenConn();
			DataTable changes = dataTable.GetChanges();
			bool flag = changes == null;
			int result;
			if (flag)
			{
				result = 0;
			}
			else
			{
				int count = changes.Rows.Count;
				bool flag2 = count == 0;
				if (flag2)
				{
					result = 0;
				}
				else
				{
					int num = 0;
					if (isAdapter)
					{
						SqlCommand sqlCommand = this.CreateCommand();
						sqlCommand.CommandText = IduSQLRuleText;
						SqlDataAdapter sqlDataAdapter = new SqlDataAdapter();
						sqlDataAdapter.SelectCommand = sqlCommand;
						SqlCommandBuilder sqlCommandBuilder = new SqlCommandBuilder();
						sqlCommandBuilder.DataAdapter = sqlDataAdapter;
						DataTable changes2 = changes.GetChanges(DataRowState.Deleted);
						bool flag3 = changes2 != null;
						if (flag3)
						{
							num += sqlDataAdapter.Update(changes2);
						}
						changes2 = changes.GetChanges(DataRowState.Modified);
						bool flag4 = changes2 != null;
						if (flag4)
						{
							num += sqlDataAdapter.Update(changes2);
						}
						changes2 = changes.GetChanges(DataRowState.Added);
						bool flag5 = changes2 != null;
						if (flag5)
						{
							num += sqlDataAdapter.Update(changes2);
						}
						result = num;
					}
					else
					{
						DataTable dataTable2 = this.GetDataTable(string.Format("{0} WHERE 0=1", IduSQLRuleText));
						dataTable2.TableName = this.GetSQLTableName(IduSQLRuleText);
						DataTable changes2 = changes.GetChanges(DataRowState.Deleted);
						bool flag6 = changes2 != null;
						if (flag6)
						{
							num += this.DataTableDelete(changes2, dataTable2);
						}
						changes2 = changes.GetChanges(DataRowState.Modified);
						bool flag7 = changes2 != null;
						if (flag7)
						{
							num += this.DataTableUpdate(changes2, dataTable2);
						}
						changes2 = changes.GetChanges(DataRowState.Added);
						bool flag8 = changes2 != null;
						if (flag8)
						{
							num += this.DataTableInsert(changes2, dataTable2);
						}
						result = num;
					}
				}
			}
			return result;
		}

		private bool IsNumericType(TypeCode typeCode)
		{
			return typeCode - TypeCode.SByte <= 10;
		}

		private int DataTableDelete(DataTable dataTable, DataTable dtRule)
		{
			DataColumnCollection columns = dtRule.Columns;
			int count = columns.Count;
			List<string> list = new List<string>();
			DataRowCollection rows = dataTable.Rows;
			int num = 0;
			foreach (DataRow dataRow in rows)
			{
				list.Clear();
				foreach (DataColumn dataColumn in columns)
				{
					string columnName = dataColumn.ColumnName;
					object obj = dataRow[columnName, DataRowVersion.Original];
					TypeCode typeCode = Type.GetTypeCode(dataColumn.DataType);
					string name = dataColumn.DataType.Name;
					bool flag = this.IsNumericType(typeCode);
					bool flag2 = flag;
					if (flag2)
					{
						bool flag3 = obj == DBNull.Value;
						if (flag3)
						{
							list.Add(string.Format("([{0}] IS NULL)", columnName));
						}
						else
						{
							list.Add(string.Format("([{0}]={1})", columnName, obj.ToString()));
						}
					}
					else
					{
						string text = name;
						string text2 = text;
						if (text2 == null)
						{
							goto IL_161;
						}
						if (!(text2 == "DateTime"))
						{
							if (!(text2 == "Byte[]"))
							{
								goto IL_161;
							}
						}
						else
						{
							bool flag4 = obj == DBNull.Value;
							if (flag4)
							{
								list.Add(string.Format("([{0}] IS NULL)", columnName));
							}
							else
							{
								list.Add(string.Format("([{0}]={1})", columnName, GPFunctions.SqlDateStr(obj)));
							}
						}
						continue;
						IL_161:
						bool flag5 = obj == DBNull.Value;
						if (flag5)
						{
							list.Add(string.Format("([{0}] IS NULL)", columnName));
						}
						else
						{
							list.Add(string.Format("([{0}]='{1}')", columnName, obj.ToString().Replace("'", "''")));
						}
					}
				}
				bool flag6 = list.Count > 0;
				if (flag6)
				{
					string sql = string.Format("DELETE {0} WHERE {1}", dtRule.TableName, string.Join(" AND ", list));
					int num2 = this.DbConn.Execute(sql);
					bool flag7 = num2 > 1;
					if (flag7)
					{
						throw new Exception("IduSQLRuleText语句中没有包含主键或者唯一索引字段。");
					}
					num += num2;
				}
			}
			return num;
		}

		private int DataTableUpdate(DataTable dataTable, DataTable dtRule)
		{
			DataColumnCollection columns = dtRule.Columns;
			int count = columns.Count;
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			Dictionary<string, int> columnWidth = this.GetColumnWidth(dtRule.TableName);
			DataRowCollection rows = dataTable.Rows;
			int num = 0;
			int bLobFieldsCount = this.GetBLobFieldsCount(dtRule);
			foreach (DataRow dataRow in rows)
			{
				list.Clear();
				list2.Clear();
				int num2 = 0;
				SqlParameter[] array = null;
				bool flag = bLobFieldsCount > 0;
				if (flag)
				{
					array = new SqlParameter[bLobFieldsCount];
				}
				foreach (DataColumn dataColumn in columns)
				{
					string columnName = dataColumn.ColumnName;
					bool flag2 = columnName == "ReceivedInfo";
					if (flag2)
					{
						num2 = num2 + 1 - 1;
					}
					object obj = dataRow[columnName];
					object obj2 = dataRow[columnName, DataRowVersion.Original];
					TypeCode typeCode = Type.GetTypeCode(dataColumn.DataType);
					string name = dataColumn.DataType.Name;
					bool flag3 = this.IsNumericType(typeCode);
					bool flag4 = flag3;
					if (flag4)
					{
						bool flag5 = typeCode == TypeCode.Double || typeCode == TypeCode.Single;
						bool flag6 = obj != DBNull.Value && obj2 != DBNull.Value;
						if (flag6)
						{
							bool flag7 = flag5;
							string text;
							string text2;
							if (flag7)
							{
								text = GPFunctions.CDbl<object>(obj).ToString();
								text2 = GPFunctions.CDbl<object>(obj2).ToString();
							}
							else
							{
								text = obj.ToString();
								text2 = obj2.ToString();
							}
							bool flag8 = text != text2;
							if (flag8)
							{
								list.Add(string.Format("[{0}]={1}", columnName, text));
							}
							list2.Add(string.Format("([{0}]={1})", columnName, text2));
						}
						else
						{
							bool flag9 = obj != DBNull.Value || obj2 != DBNull.Value;
							if (flag9)
							{
								bool flag10 = obj == DBNull.Value;
								if (flag10)
								{
									list.Add(string.Format("[{0}] = NULL", columnName));
								}
								else
								{
									bool flag11 = flag5;
									string text;
									if (flag11)
									{
										text = GPFunctions.CDbl<object>(obj).ToString();
									}
									else
									{
										text = obj.ToString();
									}
									list.Add(string.Format("[{0}]={1}", columnName, text));
								}
							}
							bool flag12 = obj2 == DBNull.Value;
							if (flag12)
							{
								list2.Add(string.Format("([{0}] IS NULL)", columnName));
							}
							else
							{
								bool flag13 = flag5;
								string text2;
								if (flag13)
								{
									text2 = GPFunctions.CDbl<object>(obj2).ToString();
								}
								else
								{
									text2 = obj2.ToString();
								}
								list2.Add(string.Format("([{0}]={1})", columnName, text2));
							}
						}
					}
					else
					{
						string text3 = name;
						string text4 = text3;
						if (text4 == null)
						{
							goto IL_3C5;
						}
						if (!(text4 == "DateTime"))
						{
							if (!(text4 == "Byte[]"))
							{
								goto IL_3C5;
							}
							string text5 = string.Format(":p{0}", num2);
							list.Add(string.Format("[{0}]={1}", columnName, text5));
							array[num2] = new SqlParameter(text5, SqlDbType.VarBinary);
							array[num2].Value = (byte[])obj;
							num2++;
						}
						else
						{
							string text = GPFunctions.SqlDateStr(obj);
							string text2 = GPFunctions.SqlDateStr(obj2);
							bool flag14 = text != text2;
							if (flag14)
							{
								list.Add(string.Format("[{0}]={1}", columnName, text));
							}
							bool flag15 = obj2 == DBNull.Value;
							if (flag15)
							{
								list2.Add(string.Format("([{0}] IS NULL)", columnName));
							}
							else
							{
								list2.Add(string.Format("([{0}]={1})", columnName, text2));
							}
						}
						continue;
						IL_3C5:
						bool flag16 = obj != DBNull.Value && obj2 != DBNull.Value;
						if (flag16)
						{
							string text = obj.ToString();
							string text2 = obj2.ToString();
							bool flag17 = text.CompareTo(text2) != 0;
							if (flag17)
							{
								list.Add(string.Format("[{0}]='{1}'", columnName, text.Replace("'", "''")));
							}
							bool flag18 = columnWidth.ContainsKey(columnName);
							if (flag18)
							{
								bool flag19 = columnWidth[columnName] <= 255;
								if (flag19)
								{
									list2.Add(string.Format("([{0}]='{1}')", columnName, text2.Replace("'", "''")));
								}
							}
							else
							{
								list2.Add(string.Format("([{0}]='{1}')", columnName, text2.Replace("'", "''")));
							}
						}
						else
						{
							bool flag20 = obj != DBNull.Value || obj2 != DBNull.Value;
							if (flag20)
							{
								bool flag21 = obj == DBNull.Value;
								if (flag21)
								{
									list.Add(string.Format("[{0}] = NULL", columnName));
								}
								else
								{
									bool flag22 = columnWidth.ContainsKey(columnName);
									string text;
									if (flag22)
									{
										text = GPFunctions.GetVarcharLengthStr(obj.ToString(), columnWidth[columnName]);
									}
									else
									{
										text = obj.ToString();
									}
									list.Add(string.Format("[{0}]='{1}'", columnName, text.Replace("'", "''")));
								}
							}
							bool flag23 = obj2 == DBNull.Value;
							if (flag23)
							{
								list2.Add(string.Format("([{0}] IS NULL)", columnName));
							}
							else
							{
								bool flag24 = columnWidth.ContainsKey(columnName);
								if (flag24)
								{
									bool flag25 = columnWidth[columnName] <= 255;
									if (flag25)
									{
										string text2 = obj2.ToString();
										list2.Add(string.Format("([{0}]='{1}')", columnName, text2.Replace("'", "''")));
									}
								}
								else
								{
									string text2 = obj2.ToString();
									list2.Add(string.Format("([{0}]='{1}')", columnName, text2.Replace("'", "''")));
								}
							}
						}
					}
				}
				bool flag26 = list.Count > 0;
				if (flag26)
				{
					string sql = string.Format("UPDATE {0} SET {1} WHERE {2}", dtRule.TableName, string.Join(",", list), string.Join(" AND ", list2));
					bool flag27 = bLobFieldsCount == 0;
					if (flag27)
					{
						num += this.DbConn.Execute(sql);
					}
					else
					{
						num += this.DbConn.Execute(sql, array);
					}
				}
			}
			return num;
		}

		private int GetBLobFieldsCount(DataTable dataTable)
		{
			int num = 0;
			DataColumnCollection columns = dataTable.Columns;
			foreach (DataColumn dataColumn in columns)
			{
				bool flag = dataColumn.DataType.Name == "Byte[]";
				if (flag)
				{
					num++;
				}
			}
			return num;
		}

		private int DataTableInsert(DataTable dataTable, DataTable dtRule)
		{
			DataColumnCollection columns = dtRule.Columns;
			int count = columns.Count;
			List<string> list = new List<string>();
			List<string> list2 = new List<string>();
			Dictionary<string, int> columnWidth = this.GetColumnWidth(dtRule.TableName);
			DataRowCollection rows = dataTable.Rows;
			int bLobFieldsCount = this.GetBLobFieldsCount(dtRule);
			int num = 0;
			foreach (DataRow dataRow in rows)
			{
				list.Clear();
				list2.Clear();
				int num2 = 0;
				SqlParameter[] array = null;
				bool flag = bLobFieldsCount > 0;
				if (flag)
				{
					array = new SqlParameter[bLobFieldsCount];
				}
				foreach (DataColumn dataColumn in columns)
				{
					string columnName = dataColumn.ColumnName;
					object obj = dataRow[columnName];
					bool flag2 = obj == DBNull.Value;
					if (!flag2)
					{
						TypeCode typeCode = Type.GetTypeCode(dataColumn.DataType);
						string name = dataColumn.DataType.Name;
						bool flag3 = this.IsNumericType(typeCode);
						bool flag4 = flag3;
						if (flag4)
						{
							bool flag5 = typeCode == TypeCode.Double || typeCode == TypeCode.Single;
							string text;
							if (flag5)
							{
								text = GPFunctions.CDbl<object>(obj).ToString();
							}
							else
							{
								text = obj.ToString();
							}
							list.Add(string.Format("[{0}]", columnName));
							list2.Add(text);
						}
						else
						{
							string text2 = name;
							string text3 = text2;
							if (text3 == null)
							{
								goto IL_20A;
							}
							string text;
							if (!(text3 == "DateTime"))
							{
								if (!(text3 == "Byte[]"))
								{
									goto IL_20A;
								}
								string text4 = string.Format(":p{0}", num2);
								list.Add(string.Format("[{0}]", columnName));
								list2.Add(text4);
								array[num2] = new SqlParameter(text4, SqlDbType.VarBinary);
								array[num2].Value = (byte[])obj;
								num2++;
							}
							else
							{
								text = GPFunctions.SqlDateStr(obj);
								list.Add(string.Format("{0}", columnName));
								list2.Add(text);
							}
							continue;
							IL_20A:
							list.Add(string.Format("[{0}]", columnName));
							bool flag6 = columnWidth.ContainsKey(columnName);
							if (flag6)
							{
								text = GPFunctions.GetVarcharLengthStr(obj.ToString(), columnWidth[columnName]);
							}
							else
							{
								text = obj.ToString();
							}
							list2.Add(string.Format("'{0}'", text.Replace("'", "''")));
						}
					}
				}
				bool flag7 = list.Count > 0;
				if (flag7)
				{
					string sql = string.Format("INSERT INTO {0} ({1}) VALUES ({2})", dtRule.TableName, string.Join(", ", list), string.Join(", ", list2));
					bool flag8 = bLobFieldsCount == 0;
					if (flag8)
					{
						num += this.DbConn.Execute(sql);
					}
					else
					{
						num += this.DbConn.Execute(sql, array);
					}
				}
			}
			return num;
		}

		private string GetSQLTableName(string sql)
		{
			sql = sql.ToUpper();
			int num = sql.IndexOf(" FROM ");
			string text = sql.Substring(num + 6);
			num = sql.IndexOf(" WHERE ");
			bool flag = num > 0;
			if (flag)
			{
				text = text.Substring(0, num);
			}
			num = text.IndexOf(",");
			bool flag2 = num > 0;
			if (flag2)
			{
				throw new Exception("DataTableSave保存中SQL语句中只能有一个表名。");
			}
			return text.Trim();
		}

		public Dictionary<string, string> GetCaptionsString(string tableName)
		{
			int num = tableName.IndexOf(".");
			bool flag = num > 0;
			string arg;
			if (flag)
			{
				arg = tableName.Substring(0, num) + ".";
			}
			else
			{
				arg = "";
			}
			string sql = string.Format("select a.name CODE,  b.value NAME from sys.columns a left join {0}sys.extended_properties b on a.object_id =b.major_id and a.column_id = b.minor_id where a.object_id=object_Id('{1}') ", arg, tableName);
			Dictionary<string, string> dictionary = new Dictionary<string, string>();
			List<MyCodeName> list = this.GetList<MyCodeName>(sql);
			int count = list.Count;
			for (int i = 0; i < count; i++)
			{
				MyCodeName myCodeName = list[i];
				bool flag2 = !string.IsNullOrEmpty(myCodeName.NAME);
				if (flag2)
				{
					dictionary.Add(myCodeName.CODE, myCodeName.NAME);
				}
			}
			return dictionary;
		}

		public Dictionary<string, int> GetColumnWidth(string tableName)
		{
			int num = tableName.IndexOf(".");
			bool flag = num > 0;
			string arg;
			if (flag)
			{
				string[] array = GPFunctions.StringToStringArray(tableName, '.');
				arg = array[0] + ".";
				tableName = array[array.Length - 1];
			}
			else
			{
				arg = "";
			}
			string sql = string.Format("select COLUMN_NAME NAME, CHARACTER_MAXIMUM_LENGTH VALUE from {0}information_schema.columns t WHERE TABLE_NAME ='{1}' AND CHARACTER_MAXIMUM_LENGTH > 0", arg, tableName);
			Dictionary<string, int> dictionary = new Dictionary<string, int>();
			List<MyNameIntValue> list = this.GetList<MyNameIntValue>(sql);
			int count = list.Count;
			for (int i = 0; i < count; i++)
			{
				MyNameIntValue myNameIntValue = list[i];
				dictionary[myNameIntValue.NAME] = Convert.ToInt32(myNameIntValue.VALUE);
			}
			return dictionary;
		}

		public List<int> getTopIntKeys(string sql, int start, int num)
		{
			List<int> list = new List<int>();
			DataTable dataTable = this.GetDataTable(sql);
			int count = dataTable.Rows.Count;
			bool flag = count < start;
			List<int> result;
			if (flag)
			{
				result = list;
			}
			else
			{
				int num2 = start + num;
				bool flag2 = count < num2;
				if (flag2)
				{
					num2 = count;
				}
				for (int i = start; i < num2; i++)
				{
					list.Add(Convert.ToInt32(dataTable.Rows[i][0]));
				}
				result = list;
			}
			return result;
		}

		private void WriteSqlCommandInfo(SqlCommand cmd)
		{
			bool flag = cmd == null;
			if (!flag)
			{
				SqlParameterCollection parameters = cmd.Parameters;
				List<string> list = new List<string>();
				list.Add(cmd.CommandText);
				foreach (SqlParameter sqlParameter in parameters)
				{
					list.Add(string.Format("{0}={1}", sqlParameter.ParameterName, sqlParameter.Value));
				}
				//GPLog.Write(LogInfoLevel.Vital, "_system", 0, "adapter.UpdateCommand", string.Join(",", list));
			}
		}
	}
}