public SqlHelper(string dbType, string connString)
{
this._dbType = (DBTypeEnum)Enum.Parse(typeof(DBTypeEnum), dbType);
switch (this._dbType)
{
case DBTypeEnum.Oracle:
this.helper = new OracleSqlHelper(connString);
break;
case DBTypeEnum.SqlServer:
this.helper = new SqlServerSqlHelper(connString);
break;
case DBTypeEnum.Sqlite:
this.helper = new SqliteHelper(connString);
break;
case DBTypeEnum.MySql:
this.helper = new MySqlHelper(connString);
break;
default:
break;
}
}
/// <summary>
/// 判断表是否在数据库中
/// </summary>
/// <param name="name"></param>
/// <returns></returns>
public bool IsExsit(string name, DBTypeEnum type)
{
switch (type)
{
case DBTypeEnum.MySql:
break;
case DBTypeEnum.SqlServer:
{
string sql = string.Format(@"IF EXISTS (SELECT * FROM dbo.SysObjects WHERE ID = object_id(N'{0}') AND OBJECTPROPERTY(ID, 'IsTable') = 1)
select 1 else select 0", name);
int result = ExecuteSql_All <int>(sql, null).First();
return(result == 1);
}
case DBTypeEnum.Sqllite:
{
string sql = "select count(*) from sqlite_master where type='table' and name = '@name'";
int result = ExecuteSql_All <int>(sql, new { name = name }).First();
return(result == 1);
}
case DBTypeEnum.Oracle:
break;
default:
break;
}
return(false);
}
public static bool Migrate(ILogger logger, DBTypeEnum dbType, string connectionString, bool create)
{
if (DefaultConnectionString == null)
{
DefaultConnectionString = connectionString;
}
IdentityDbContextBase dbContext = null;
try
{
switch (dbType)
{
case DBTypeEnum.Oracle:
dbContext = new IdentityDbContextBaseMigrOracle();
break;
case DBTypeEnum.PostgreSQL:
dbContext = new IdentityDbContextBaseMigrPostgreSQL();
break;
case DBTypeEnum.SQLServer:
dbContext = new IdentityDbContextBaseMigrSQLServer();
break;
}
Migrate(logger, dbContext, create);
}
finally
{
dbContext?.Dispose();
}
return(false);
}
/// <summary>
/// 设置数据库类型
/// </summary>
/// <param name="type">数据库类型</param>
public static void SetDBType(DBTypeEnum type)
{
// 设置数据库类型
_dbType = type;
// 设置数据库Dialect
if (type == DBTypeEnum.SQLSERVER)
{
//默认实现为SQLSERVER
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.SqlServerDialect();
}
else if (type == DBTypeEnum.ORACLE)
{
//Oracle 数据库
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.OracleDialect();
}
else if (type == DBTypeEnum.MYSQL)
{
//MySQL 数据库
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.MySqlDialect();
}
else if (type == DBTypeEnum.KINGBASE)
{
//KingBase 数据库
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.KingbaseSqlDialect();
}
}
/// <summary>
/// 创建command
/// </summary>
/// <param name="commandText"> Transact-SQL 语句、表名或存储过程</param>
/// <returns></returns>
public static SqlCommand createCommand(string commandText,
CommandType commandType, DBTypeEnum dbtypeenum)
{
SqlConnection conn = ConnFactory.getConnection(dbtypeenum);
SqlCommand cmd = new SqlCommand();
cmd.Connection = conn;
cmd.CommandText = commandText;
cmd.CommandType = commandType;
return cmd;
}
protected virtual void Seed(ModelBuilder modelBuilder, DBTypeEnum dbType)
{
modelBuilder.Entity <RGFRole>().HasData(
new RGFRole {
RoleId = "1", RoleName = "Administrators", Source = "RGF"
},
new RGFRole {
RoleId = "2", RoleName = "Users", Source = "RGF"
}
);
}
public static bool TestQuery(DBTypeEnum dbType, string hostName, string db, string user, string pwd, string query)
{
string connStr = "", format = "";
DBLinker linker;
try
{
switch (dbType)
{
case DBTypeEnum.ODBC:
format = "Server={0};Database={1};Uid={2};Pwd={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker =new OdbcLinker(connStr);
break;
case DBTypeEnum.OLE_DB:
format = "Server={0};Database={1};Uid={2};Pwd={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker = new OleDbLinker(connStr);
break;
case DBTypeEnum.Oracle:
format = "host={0};Data source={1};User id={2};Password={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker = new OracleLinker(connStr);
break;
case DBTypeEnum.SQL_Server:
format = "Data Source={0};Initial Catalog= {1};User Id={2};Password={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker = new SqlServerLinker(connStr);
break;
default:
format = "Data Source={0};Initial Catalog= {1};User Id={2};Password={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker = new SqlServerLinker(connStr);
break;
}
DataTable dt = linker.ExecuteSQL(query);
int count = dt.Rows.Count;
dt.Clear();
linker.Close();
if (count > 0)
return true;
else
return false;
}
catch (Exception e)
{
#if DEBUG
System.Console.WriteLine(e.StackTrace.ToString());
#endif
return false;
}
}
public static bool TestDbLink(DBTypeEnum dbType,string hostName,string db,string user,string pwd)
{
string connStr = "", format="";
DbConnection conn;
try
{
switch (dbType)
{
case DBTypeEnum.ODBC:
format = "Server={0};Database={1};Uid={2};Pwd={3};";
connStr = string.Format(format, hostName, db, user, pwd);
conn = new OdbcConnection(connStr);
break;
case DBTypeEnum.OLE_DB:
format = "Server={0};Database={1};Uid={2};Pwd={3};";
connStr = string.Format(format, hostName, db, user, pwd);
conn = new OleDbConnection(connStr);
break;
case DBTypeEnum.Oracle:
format = "host={0};Data source={1};User id={2};Password={3};";
connStr = string.Format(format, hostName, db, user, pwd);
conn = new OracleConnection(connStr);
break;
case DBTypeEnum.SQL_Server:
format = "Data Source={0};Initial Catalog= {1};User Id={2};Password={3};";
connStr = string.Format(format, hostName, db, user, pwd);
conn = new SqlConnection(connStr);
break;
default:
format = "Data Source={0};Initial Catalog= {1};User Id={2};Password={3};";
connStr = string.Format(format, hostName, db, user, pwd);
conn = new SqlConnection(connStr);
break;
}
conn.Open();
if (conn.State != System.Data.ConnectionState.Open)
{
conn.Close();
return false;
}
conn.Close();
return true;
}
catch (Exception e)
{
#if DEBUG
System.Console.WriteLine(e.StackTrace.ToString());
#endif
return false;
}
}
private static void executeSqls(string[] sqlArray, List<Hashtable> args,
List<SqlParameter[]> paras, DBTypeEnum dbtypeenum)
{
SqlConnection conn;
SqlTransaction myTrans;
Hashtable hst;
SqlCommand cmd = new SqlCommand();
int i;
if ((sqlArray != null) && sqlArray.Length > 0)
{
conn = ConnFactory.getConnection(dbtypeenum);
cmd.Connection = conn;
ConnFactory.openConn(conn);
myTrans = conn.BeginTransaction();
cmd.Transaction = myTrans;
try
{
for (i = 0; i <= (sqlArray.Length - 1); i++)
{
cmd.CommandText = sqlArray[i];
if (args != null && args[i] != null)
{
hst = args[i];
buildCommand(cmd, hst);
}
if (paras != null && paras[i] != null)
{
cmd.Parameters.AddRange(paras[i]);
}
cmd.ExecuteNonQuery();
cmd.Parameters.Clear();
}
myTrans.Commit();
}
catch (Exception ex)
{
myTrans.Rollback();
//LogManger.WriteErrorLogWin("DBTranUtil.executeSqls:发生了错误" + ex.Message);
throw (ex);
}
finally
{
ConnFactory.closeConn(conn);
}
}
}
/// <summary>
/// 设置数据库类型相关的变量
/// </summary>
/// <param name="type">数据库类型</param>
private static void InitializeDBType(DBTypeEnum type)
{
DBTypeExtenstions.SetDBType(type);
//update sql dialect in dapper extension
if (type == DBTypeEnum.ORACLE)
{
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.OracleSqlDialect();
}
else if (type == DBTypeEnum.MYSQL)
{
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.MySqlDialect();
}
else if (type == DBTypeEnum.KINGBASE)
{
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.KingbaseSqlDialect();
}
}
/// <summary>
/// 设置数据库类型相关的变量
/// </summary>
/// <param name="type">数据库类型</param>
private static void InitializeDBType(DBTypeEnum type)
{
//指定某个具体的数据库类型，仅第一次赋值，其后不用赋值。
if (type == DBTypeEnum.SQLSERVER)
{
DBTypeExtenstions.SetDBType(type, null); //默认实现为SQLSERVER
}
else if (type == DBTypeEnum.ORACLE)
{
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.OracleSqlDialect();
//DBTypeExtenstions.SetDBType(type, new OracleWfDataProvider());
}
else if (type == DBTypeEnum.MYSQL)
{
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.MySqlDialect();
//DBTypeExtenstions.SetDBType(type, new MySqlWfDataProvider());
}
}
public MakinoDB(DBTypeEnum dbType, string dbConnStr, StatusDB status,
BlackMaple.MachineFramework.JobLogDB log)
{
_status = status;
_logDb = log;
switch (dbType)
{
case DBTypeEnum.SqlLocal:
_db = new System.Data.SqlClient.SqlConnection("Data Source = (localdb)\\MSSQLLocalDB; Initial Catalog = Makino;");
_db.Open();
dbo = "dbo.";
break;
case DBTypeEnum.SqlConnStr:
_db = new System.Data.SqlClient.SqlConnection(dbConnStr);
_db.Open();
dbo = "dbo.";
break;
}
}
/// <summary>
/// 设置数据库类型变量
/// </summary>
/// <param name="type">数据库类型</param>
/// <param name="provider">数据提供者</param>
public static void SetDBType(DBTypeEnum type, IWfDataProvider provider = null)
{
dbType = type;
wfDataProvider = provider;
if (type == DBTypeEnum.SQLSERVER)
{
//默认实现为SQLSERVER
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.SqlServerDialect();
}
else if (type == DBTypeEnum.ORACLE)
{
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.OracleSqlDialect();
}
else if (type == DBTypeEnum.MYSQL)
{
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.MySqlDialect();
}
else if (type == DBTypeEnum.KINGBASE)
{
DapperExtensions.DapperExtensions.SqlDialect = new DapperExtensions.Sql.KingbaseSqlDialect();
}
}
//判断是否能够正常连接
public static bool connState(DBTypeEnum dbtypeenum)
{
System.Data.SqlClient.SqlConnection conn = ConnFactory.getConnection(dbtypeenum);
try
{
conn.Open();
if (conn.State != ConnectionState.Open)
{
ConnVarible.connStr = "";
return false;
}
}
catch (Exception)
{
ConnVarible.connStr = "";
return false;
}
finally
{
ConnFactory.closeConn(conn);
}
return true;
}
/// <summary>
/// 表对应实体特性
/// </summary>
/// <param name="db">指定数据库</param>
/// <param name="dbType">指定数据库类型</param>
public TableAttribute(string db, DBTypeEnum dbType)
{
DB = db;
DBType = dbType;
}
public static int ExecuteSqlWithParams(string sql, SqlParameter[] sqlParas,DBTypeEnum dbtypeenum)
{
return executeCud(sql, CommandType.Text, null, sqlParas,dbtypeenum);
}
public static bool Exists(string strSql,DBTypeEnum dbtypeenum)
{
return Exists(strSql, dbtypeenum, null);
}
public static DataTable querySqlTable(string sql,DBTypeEnum dbtypeenum)
{
return queryTable(sql, CommandType.Text, null, null,dbtypeenum);
}
public static DataTable querySqlTable(string sql, SqlParameter[] sqlParas, DBTypeEnum dbtypeenum)
{
DataTable dt = queryTable(sql, CommandType.Text, null, sqlParas,dbtypeenum);
return dt;
}
public static System.Collections.Generic.List<String> queryDataList(String sql,DBTypeEnum dbtypeenum)
{
return getDataList(sql, null,dbtypeenum);
}
public static DataSet querySqlSet(string sql, Hashtable args, DBTypeEnum dbtypeenum)
{
DataTable dt = queryTable(sql, CommandType.Text, args, null, dbtypeenum);
var ds = new DataSet();
ds.Tables.Add(dt);
return ds;
}
public InstrumentManager(IDMLOperable DMLOperable, DBTypeEnum DBType)
{
this.dmlOperable = DMLOperable;
this.dBType = DBType;
}
public static IInstrumentManager NewInstance(IDMLOperable DMLOperable, DBTypeEnum DBType)
{
return(new InstrumentManager(DMLOperable, DBType));
}
/// <summary>
/// 设置数据库类型变量
/// </summary>
/// <param name="type"></param>
/// <param name="provider"></param>
public static void SetDBType(DBTypeEnum type, IWfDataProvider provider)
{
dbType = type;
wfDataProvider = provider;
}
/// <summary>
/// 设置数据库类型变量
/// </summary>
/// <param name="type"></param>
/// <param name="provider"></param>
public static void SetDBType(DBTypeEnum type)
{
dbType = type;
}
public static DataTable queryProTable4Params(string proName, SqlParameter[] args,DBTypeEnum dbtypeenum)
{
return queryTable(proName, CommandType.StoredProcedure, null, args,dbtypeenum);
}
public static DataTable queryProTable(string proName, Hashtable args,DBTypeEnum dbtypeenum)
{
return queryTable(proName, CommandType.StoredProcedure, args, null,dbtypeenum);
}
/// <summary>
/// 表对应实体特性
/// </summary>
/// <param name="db">指定数据库</param>
/// <param name="dbType">指定数据库类型</param>
/// <param name="table">指定表名</param>
public TableAttribute(string db, DBTypeEnum dbType, string table)
{
DB = db;
DBType = dbType;
Table = table;
}
public static Dictionary<string, List<FieldInfo>> GetQueryTableFields(DBTypeEnum dbType, string connStr, string query)
{
Dictionary<string, List<FieldInfo>> tableFieldDict = new Dictionary<string, List<FieldInfo>>();
DBLinker linker;
try
{
switch (dbType)
{
case DBTypeEnum.ODBC:
linker = new OdbcLinker(connStr);
break;
case DBTypeEnum.OLE_DB:
linker = new OleDbLinker(connStr);
break;
case DBTypeEnum.Oracle:
linker = new OracleLinker(connStr);
break;
case DBTypeEnum.SQL_Server:
linker = new SqlServerLinker(connStr);
break;
default:
linker = new SqlServerLinker(connStr);
break;
}
List<string> tableList = SupportClass.QueryParser.TablesInQuery(query);
foreach (string table in tableList)
{
DataTable dt = linker.ExecuteSQL(SupportClass.QueryParser.TopOneOfTable(table));
List<FieldInfo> fieldList = new List<FieldInfo>();
foreach (DataColumn column in dt.Columns)
{
fieldList.Add(new FieldInfo(column.ColumnName,column.DataType,column.Unique));
}
if (tableFieldDict.ContainsKey(table) == false)
tableFieldDict.Add(table, fieldList);
dt.Clear();
}
linker.Close();
}
catch (Exception e)
{
#if DEBUG
System.Console.WriteLine(e.StackTrace.ToString());
#endif
}
return tableFieldDict;
}
public NuclideManager(IDMLOperable DMLOperable, DBTypeEnum DBType)
{
this.dmlOperable = DMLOperable;
this.dBType = DBType;
}
public static string getUniqueResult(string sql, SqlParameter[] paras, DBTypeEnum dbtypeenum)
{
return getUniqueResult(sql, null, dbtypeenum, paras);
}
public static NuclideManager NewInstance(IDMLOperable DMLOperable, DBTypeEnum DBType)
{
return(new NuclideManager(DMLOperable, DBType));
}
public static System.Collections.Generic.List<String> queryDataList(String sql, SqlParameter[] paras, DBTypeEnum dbtypeenum)
{
return getDataList(sql, paras,dbtypeenum);
}
/// <summary>
/// 操作类型，读或写
/// </summary>
/// <param name="DbType">the database type, if t is Default, the value in appsettings will be used</param>
/// <param name="Operation">Operation</param>
/// <param name="CsName">the key of the ConnectionString in appsettings</param>
public FixConnectionAttribute(DBTypeEnum DbType, DBOperationEnum Operation = DBOperationEnum.Default, string CsName = "")
{
this.CsName = CsName;
this.Operation = Operation;
this.DbType = DbType;
}
public static DataSet querySqlSet(string sql, SqlParameter[] sqlParas, DBTypeEnum dbtypeenum)
{
DataTable dt = queryTable(sql, CommandType.Text, null, sqlParas,dbtypeenum);
var ds = new DataSet();
ds.Tables.Add(dt);
return ds;
}
/// <summary>
/// 执行cud
/// </summary>
/// <param name="commandText"></param>
/// <param name="commandType"></param>
/// <param name="args"></param>
/// <returns></returns>
protected static int executeCud(string commandText,
CommandType commandType, Hashtable hts, SqlParameter[] paras, DBTypeEnum dbtypeenum)
{
int returnValue = 0;
SqlCommand cmd = createCommand(commandText, commandType,dbtypeenum);
if (hts != null)
{
buildCommand(cmd, hts);
}
if (paras != null) cmd.Parameters.AddRange(paras);
try
{
ConnFactory.openConn(cmd.Connection);
returnValue = Convert.ToInt32(cmd.ExecuteScalar());
}
catch (Exception ex)
{
//LogManger.WriteErrorLogWin("DBUtil.executeCud:发生了错误" + ex.Message);
throw (ex);
}
finally
{
ConnFactory.closeConn(cmd.Connection);
}
return returnValue;
}
public static DataTable querySqlTable(string sql, Hashtable args, DBTypeEnum dbtypeenum)
{
DataTable dt = queryTable(sql, CommandType.Text, args, null,dbtypeenum);
//return queryTable(sql, CommandType.Text, args,null);
return dt;
}
/// <summary>
/// 获得唯一的结果
/// </summary>
/// <param name="sql"></param>
/// <param name="args"></param>
/// <param name="paras"></param>
/// <returns></returns>
protected static string getUniqueResult(string sql, Hashtable args, DBTypeEnum dbtypeenum, SqlParameter[] paras)
{
using (SqlConnection connection = ConnFactory.getConnection(dbtypeenum))
{
using (SqlCommand cmd = new SqlCommand(sql, connection))
{
try
{
connection.Open();
buildCommand(cmd, args);
if (paras != null) cmd.Parameters.AddRange(paras);
object obj = cmd.ExecuteScalar();
if ((Object.Equals(obj, null)) || (Object.Equals(obj, System.DBNull.Value)))
{
return string.Empty;
}
else
{
return obj.ToString();
}
}
catch (System.Data.SqlClient.SqlException e)
{
ConnFactory.closeConn(connection);
throw e;
}
}
}
}
public static int ExecuteSql(string sql, Hashtable hts, DBTypeEnum dbtypeenum)
{
return executeCud(sql, CommandType.Text, hts, null, dbtypeenum);
}
public static IMaintenanceManager NewInstance(IDMLOperable DMLOperable, DBTypeEnum DBType)
{
return(new MaintenanceManager(DMLOperable, DBType));
}
public static Int32 ExecuteSqlWithParams(String sql, CommandType type, SqlParameter[] sqlParas, DBTypeEnum dbtypeenum)
{
return executeCud(sql, type, null, sqlParas,dbtypeenum);
}
public EmptyContext(string cs, DBTypeEnum dbtype)
{
CSName = cs;
DBType = dbtype;
}
public DataContext(string cs, DBTypeEnum dbtype, string version = null)
: base(cs, dbtype, version)
{
}
public AccountManager(IDMLOperable DMLOperable, DBTypeEnum DBType)
{
this.dmlOperable = DMLOperable;
this.dBType = DBType;
}
public static int GetValue(this DBTypeEnum dbType)
{
return((int)dbType);
}
public EmptyContext(string cs, DBTypeEnum dbtype, string version = null)
{
CSName = cs;
DBType = dbtype;
Version = version;
}
/// <summary>
/// 获得首列结果
/// </summary>
/// <param name="sql"></param>
/// <returns></returns>
protected static System.Collections.Generic.List<String> getDataList(String sql, SqlParameter[] paras, DBTypeEnum dbtypeenum)
{
System.Collections.Generic.List<String> retLStr = new System.Collections.Generic.List<string>();
SqlConnection conn = ConnFactory.getConnection(dbtypeenum);
SqlCommand cmd = createCommand(sql, CommandType.Text,dbtypeenum);
cmd.Connection = conn;
if (paras != null)
cmd.Parameters.AddRange(paras);
try
{
conn.Open();
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
retLStr.Add(reader[0].ToString());
}
}
finally
{
conn.Close();
}
return retLStr;
}
private static SqlConnection createConnection(DBTypeEnum dbtypeenum)
{
System.Data.SqlClient.SqlConnection conn = new SqlConnection();
conn.ConnectionString = ConfigurationManager.ConnectionStrings[Enum.GetName(typeof(DBTypeEnum), dbtypeenum)].ConnectionString;
return conn;
}
/// <summary>
/// 返回DataTable结果的数据
/// </summary>
/// <param name="commandText">Transact-SQL 语句、表名或存储过程</param>
/// <param name="commandType">command类型</param>
/// <param name="args">参数</param>
/// <param name="paras">参数</param>
/// <returns></returns>
protected static DataTable queryTable(string commandText,
CommandType commandType, Hashtable args, SqlParameter[] paras,DBTypeEnum dbtypeenum)
{
SqlCommand cmd = createCommand(commandText, commandType,dbtypeenum);
DataSet sqlDataSet = new DataSet();
SqlDataAdapter adapter = new SqlDataAdapter();
if (args != null)
{
buildCommand(cmd, args);
}
if (paras != null) cmd.Parameters.AddRange(paras);
try
{
//如果调用 Fill 之前 IDbConnection 已关闭，则将其打开以检索数据，然后再将其关闭。
//如果调用 Fill 之前连接已打开，它将保持打开状态
adapter.SelectCommand = cmd;
adapter.Fill(sqlDataSet, "tempTable");
}
catch (Exception ex)
{
throw ex;
//LogManger.WriteErrorLogWin("DBUtil.queryTable:发生了错误" + ex.Message);
}
finally
{
ConnFactory.closeConn(cmd.Connection);
}
if (sqlDataSet.Tables.Count > 0)
{
return sqlDataSet.Tables["tempTable"];
}
else
{
return null;
}
}
public static bool TestFields(DBTypeEnum dbType, string hostName, string db, string user, string pwd, string query,string fields)
{
string connStr = "", format = "";
DBLinker linker;
try
{
switch (dbType)
{
case DBTypeEnum.ODBC:
format = "Server={0};Database={1};Uid={2};Pwd={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker = new OdbcLinker(connStr);
break;
case DBTypeEnum.OLE_DB:
format = "Server={0};Database={1};Uid={2};Pwd={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker = new OleDbLinker(connStr);
break;
case DBTypeEnum.Oracle:
format = "host={0};Data source={1};User id={2};Password={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker = new OracleLinker(connStr);
break;
case DBTypeEnum.SQL_Server:
format = "Data Source={0};Initial Catalog= {1};User Id={2};Password={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker = new SqlServerLinker(connStr);
break;
default:
format = "Data Source={0};Initial Catalog= {1};User Id={2};Password={3};";
connStr = string.Format(format, hostName, db, user, pwd);
linker = new SqlServerLinker(connStr);
break;
}
DataTable dt = linker.ExecuteSQL(query);
int count = dt.Rows.Count;
if (count < 0)
{
dt.Clear();
linker.Close();
return false;
}
List<IndexField> fpList = new List<IndexField>();
if (fields.IndexOf(')') > 0)
{
string[] split = SupportClass.String.Split(fields, ")");
foreach (string token in split)
fpList.Add(new IndexField(token));
}
else
{
string[] split = SupportClass.String.Split(fields, ",");
foreach (string token in split)
fpList.Add(new IndexField(token));
}
bool find;
foreach (IndexField fp in fpList)
{
find = false;
foreach(DataColumn column in dt.Columns)
{
if(column.ColumnName.ToLower().CompareTo(fp.Name.ToLower())==0)
{
find = true;
break;
}
}
if (!find)
{
dt.Clear();
linker.Close();
return false;
}
}
dt.Clear();
linker.Close();
return true;
}
catch (Exception e)
{
#if DEBUG
System.Console.WriteLine(e.StackTrace.ToString());
#endif
return false;
}
}
public FrameworkContext(string cs, DBTypeEnum dbtype)
{
CSName = cs;
DBType = dbtype;
}
/// <summary>
/// 初始化连接串
/// </summary>
/// <param name="strConn">连接串</param>
public static void InitConnectionString(string databaseType, string strConn)
{
DBTypeEnum dbType = (DBTypeEnum)Enum.Parse(typeof(DBTypeEnum), databaseType.ToUpper());
InitConnectionStringInt(dbType, strConn);
}
public FrameworkContext(string cs, DBTypeEnum dbtype, string version = null) : base(cs, dbtype, version)
{
}
/// <summary>
/// 初始化连接串
/// </summary>
/// <param name="strConn">连接串</param>
private static void InitConnectionStringInt(DBTypeEnum databaseType, string strConn)
{
_dbType = databaseType;
_connectionString = strConn;
}
public static SqlConnection getConnection(DBTypeEnum dbtypeenum)
{
return createConnection(dbtypeenum);
}
public static bool Exists(string strSql,DBTypeEnum dbtypeenum, SqlParameter[] paras)
{
string obj = getUniqueResult(strSql, null, dbtypeenum, paras);
int cmdresult;
if (Object.Equals(obj, string.Empty))
{
cmdresult = 0;
}
else
{
cmdresult = int.Parse(obj);
}
if (cmdresult == 0)
{
return false;
}
else
{
return true;
}
}
public DataContext(string cs, DBTypeEnum dbtype)
: base(cs, dbtype)
{
}
public static string getUniqueResult(string sql,DBTypeEnum dbtypeenum)
{
return getUniqueResult(sql, null, dbtypeenum, null);
}
public FrameworkContext(string cs, DBTypeEnum dbtype) : base(cs, dbtype)
{
}
public static string getUniqueResult(string sql, Hashtable args,DBTypeEnum dbtypeenum)
{
return getUniqueResult(sql, args, dbtypeenum, null);
}
