/// <summary>
/// 构造数据库操作类
/// </summary>
/// <param name="ServerName">服务器名称或net服务名</param>
/// <param name="DataBaseName"></param>
/// <param name="UserIdName"></param>
/// <param name="Password"></param>
public SybaseHelperByODBC(eDBType at2, string ServerName, string DataBaseName, string UserIdName, string Password)
{
switch (at2)
{
case eDBType.Access:
//this.strConn = ReadXmlGetConnectString(at.ToString());
break;
case eDBType.Oracle:
//Provider=OraOLEDB.Oracle.1;Persist Security Info=True;User ID=sjy;Password=sjy;Data Source=sjyweb
//this.strConntionString = " Data Source=" + ServerName + ";User ID=" + UserIdName + ";Password="******"";
this.strConntionString = "Provider=OraOLEDB.Oracle.1;Persist Security Info=True;User ID=" + UserIdName + ";Password="******";Data Source=" + ServerName + "";
break;
case eDBType.SqlServer:
this.strConntionString = "Provider=SQLOLEDB;server=" + ServerName + ";database=" + DataBaseName + ";uid=" + UserIdName + ";pwd=" + Password + "";
break;
case eDBType.Custom:
break;
case eDBType.Sybase:
//this.strConntionString = "Provider=Sybase.ASEOLEDBProvider.2;Data Source=" + ServerName + ";Initial Catalog=" + DataBaseName + ";User id=" + UserIdName + ";Password="******"";
this.strConntionString = "Dsn=" + ServerName + ";Uid=" + UserIdName + ";Pwd=" + Password + "";
break;
default:
break;
}
connOpen();
}
private string FillBusinessDays(IDBRevision sender, eDBType dBType)
{
return
(@"WITH DaysCTE AS
(
SELECT TOP 0 ID = NEWID(), ShortName = '', FullName = ''
UNION ALL SELECT ID = NEWID(), ShortName = 'Mon', FullName = 'Monday'
UNION ALL SELECT ID = NEWID(), ShortName = 'Tue', FullName = 'Tuesday'
UNION ALL SELECT ID = NEWID(), ShortName = 'Wed', FullName = 'Wednesday'
UNION ALL SELECT ID = NEWID(), ShortName = 'Thu', FullName = 'Thursday'
UNION ALL SELECT ID = NEWID(), ShortName = 'Fri', FullName = 'Friday'
UNION ALL SELECT ID = NEWID(), ShortName = 'Sat', FullName = 'Saturday'
UNION ALL SELECT ID = NEWID(), ShortName = 'Sun', FullName = 'Sunday'
)
INSERT INTO Flyinline.BusinessDay (ID, shortName, fullname)
SELECT
t.ID, t.ShortName, t.FullName
FROM
DaysCTE t
LEFT JOIN Flyinline.BusinessDay d ON t.ShortName = d.ShortName AND t.FullName = d.FullName
WHERE
d.ID is null
");
}
/// <summary>
/// 返回数据库操作类
/// </summary>
/// <param name="at">数据库类型</param>
public SybaseHelperByODBC(eDBType at)
{
string[] temp;
string pwd = string.Empty;
temp = Encrypt.DeCode(ReadXmlGetConnectString(at.ToString())).Split(';');
if (temp.Length == 2)
{
this.strConntionString = temp[0];
pwd = temp[1];
}
else
{
this.strConntionString = temp[0];
pwd = "";
}
if (at == eDBType.Access)
{
//jet OleDB:Database Password=123456
//this.strConntionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + Application.StartupPath + this.strConntionString;
this.strConntionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + Application.StartupPath + this.strConntionString + ";jet OleDB:Database Password="******"";
}
connOpen();
}
private string FillDrzava(IDBRevision sender, eDBType dBType)
{
var ret = string.Format(
@"GO
WITH
Pass0 as (select 1 as C union all select 1), --2 rows
Pass1 as (select 1 as C from Pass0 as A, Pass0 as B),--4 rows
Pass2 as (select 1 as C from Pass1 as A, Pass1 as B),--16 rows
Pass3 as (select 1 as C from Pass2 as A, Pass2 as B),--256 rows
Pass4 as (select 1 as C from Pass3 as A, Pass3 as B),--65536 rows
Pass5 as (select 1 as C from Pass4 as A, Pass4 as B),
--I removed Pass5, since I'm only populating the Numbers table to 10,000
Tally as (select row_number() over(order by C) as Number from Pass5)
INSERT INTO {0} (ID, Naziv)
SELECT
ID = NEWID(),
Naziv = CAST(Number as nvarchar(512))
FROM Tally
WHERE
Number <= 10000
WAITFOR DELAY '00:00:03'
", sender.Parent.SchemaName + "." + sender.Parent.SchemaObjectName);
return(ret);
}
/// <summary>
/// 返回数据库操作类
/// </summary>
/// <param name="at">数据库类型</param>
public SybaseHelper(eDBType at)
{
string[] temp;
string pwd = string.Empty;
temp = Encrypt.DeCode(ReadXmlGetConnectString(at.ToString())).Split(';');
if (temp.Length == 2)
{
this.strConntionString = temp[0];
pwd = temp[1];
}
else
{
this.strConntionString = temp[0];
pwd = "";
}
if (at == eDBType.Access)
{
//jet OleDB:Database Password=123456
//this.strConntionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + Application.StartupPath + this.strConntionString;
this.strConntionString = "Provider=Microsoft.Jet.OLEDB.4.0;Data Source=" + Application.StartupPath + this.strConntionString + ";jet OleDB:Database Password="******"";
}
connOpen();
}
private static void CleanVariablesBasedInAttribute(Artech.Genexus.Common.Objects.Attribute a, IOutputService output, KBObject objRef)
{
output.AddLine("Cleaning variables references to " + a.Name + " in " + objRef.Name);
VariablesPart vp = objRef.Parts.Get <VariablesPart>();
if (vp != null)
{
foreach (Variable v in vp.Variables)
{
if (!v.IsStandard)
{
if ((v.AttributeBasedOn != null) && (a.Name == v.AttributeBasedOn.Name))
{
output.AddLine("&" + v.Name + " based on " + a.Name);
eDBType type = v.Type;
int length = v.Length;
bool signed = v.Signed;
string desc = v.Description;
int dec = v.Decimals;
//Modifico la variable, para que no se base en el atributo.
v.AttributeBasedOn = null;
v.Type = type;
v.Decimals = dec;
v.Description = desc;
v.Length = length;
v.Signed = signed;
}
}
}
}
}
private string FillRolePermissions(IDBRevision sender, eDBType dBType)
{
return
(@"
;WITH
RolesCTE AS
(
SELECT RoleID = ID FROM Common.Role t WHERE t.Name IN ('Client', 'BusinessOwner')
),
ClaimsCTE AS
(
SELECT ClaimID = ID FROM Common.Claim t WHERE t.Name IN ('Routes.HomePage.View')
)
INSERT INTO Common.RolePermission (ID, RoleID, ClaimID, CanExecute)
SELECT a.*
FROM
(
SELECT ID = NEWID(), RoleID, ClaimID, CanExecute = 1
FROM
RolesCTE r,
ClaimsCTE c
) a
LEFT JOIN Common.RolePermission existing on a.RoleID = existing.RoleID and a.ClaimID = existing.ClaimID
WHERE existing.ID IS NULL
");
}
private static void CleanSDT(Artech.Genexus.Common.Objects.Attribute a, IOutputService output, KBObject objRef)
{
if (objRef is SDT)
{
output.AddLine("Cleaning SDT references to " + a.Name + " in " + objRef.Name);
SDTStructurePart sdtstruct = objRef.Parts.Get <SDTStructurePart>();
foreach (IStructureItem structItem in sdtstruct.Root.Items)
{
SDTItem sdtItem = (SDTItem)structItem;
if (sdtItem.BasedOn.Key == a.Key)
{
output.AddLine("..." + sdtItem.Name + " based on " + a.Name);
eDBType type = sdtItem.Type;
int length = sdtItem.Length;
bool signed = sdtItem.Signed;
string desc = sdtItem.Description;
int dec = sdtItem.Decimals;
//Modifico la variable, para que no se base en el atributo.
sdtItem.AttributeBasedOn = null;
sdtItem.Type = type;
sdtItem.Decimals = dec;
sdtItem.Description = desc;
sdtItem.Length = length;
sdtItem.Signed = signed;
}
}
}
}
private string FillAdmin2(IDBRevision sender, eDBType dBType)
{
return
(@"--WAITFOR DELAY '00:00:01'
--exec sp_updatestats
INSERT INTO Common.Role (ID, Name)
SELECT TOP 0 NEWID(), 'Administrator'");
}
public Database GetDB(eDBType type, ushort id)
{
Database db;
if (m_db_instance.TryGetValue((int)type + "_" + id, out db))
{
return(db);
}
return(null);
}
public override string GetSqlDelete(eDBType dBType)
{
string ret = "";
ret = string.Format(
@"GO
DROP PROCEDURE {0}.{1}", SchemaName, Name);
return(ret);
}
/// <summary>
/// 转换为数据库的对应参数类型
/// </summary>
/// <param name="dbType"></param>
/// <returns></returns>
public System.Data.Common.DbParameter[] ConvertToDbParameter(eDBType dbType)
{
if (_dicParamNameValue == null | _dicParamNameValue.Count == 0)
{
return(new System.Data.Common.DbParameter[0]);
}
System.Data.Common.DbParameter[] pras = new System.Data.Common.DbParameter[_dicParamNameValue.Count];
switch (dbType)
{
case eDBType.Oracle:
System.Data.OracleClient.OracleParameter[] pOras =
new System.Data.OracleClient.OracleParameter[_dicParamNameValue.Count];
int iOra = 0;
foreach (string name in _dicParamNameValue.Keys)
{
pOras[iOra++] = new System.Data.OracleClient.OracleParameter(name, _dicParamNameValue[name]);
}
return(pOras);
case eDBType.SqlServer:
System.Data.SqlClient.SqlParameter[] pSqls =
new System.Data.SqlClient.SqlParameter[_dicParamNameValue.Count];
int iSql = 0;
foreach (string name in _dicParamNameValue.Keys)
{
pSqls[iSql++] = new System.Data.SqlClient.SqlParameter(name, _dicParamNameValue[name]);
}
return(pSqls);
case eDBType.Access:
System.Data.OleDb.OleDbParameter[] oSqls =
new System.Data.OleDb.OleDbParameter[_dicParamNameValue.Count];
int iOledb = 0;
foreach (string name in _dicParamNameValue.Keys)
{
oSqls[iOledb++] = new System.Data.OleDb.OleDbParameter(name, _dicParamNameValue[name]);
}
return(oSqls);
case eDBType.MySql:
case eDBType.DB2:
case eDBType.Sybase:
default:
break;
}
return(new System.Data.Common.DbParameter[0]);
}
/// <summary>
/// 获取数据库表列表
/// </summary>
public System.Data.DataTable GetTables(eDBType type)
{
Database db = GetDB(type);
if (db == null)
{
return(null);
}
return(db.GetTables());
}
/// <summary>
/// 通过配置文件的配置来创建数据库连接，如果有多个同类型的连接，则只取第一个
/// </summary>
/// <param name="dbtype">对应配置中的DBType属性</param>
/// <returns></returns>
public static IDBOperator CreateByConfig(eDBType dbtype)
{
var dic = DBConfigDic;
if (dic.ContainsKey(dbtype))
{
return(Create(dbtype, dic[dbtype].First().Value));
}
throw new Exception("在配置中没有找到数据库类型：" + dbtype);
}
internal static bool TypeHasToBeInDomain(eDBType type)
{
if (type != eDBType.Boolean && type != eDBType.BITMAP && type != eDBType.BINARY && type != eDBType.GX_SDT &&
type != eDBType.GX_EXTERNAL_OBJECT && type != eDBType.GX_USRDEFTYP && type != eDBType.GX_BUSCOMP && type != eDBType.GX_BUSCOMP_LEVEL)
{
return(true);
}
else
{
return(false);
}
}
public override string GetSqlModify(eDBType dBType)
{
string ret = "";
ret = string.Format(
@"GO
ALTER PROCEDURE {0}.{1}
{2}
AS
{3}
", SchemaName, Name, ((DBStoredProcedureDescriptor)Descriptor).Parameters, ((DBStoredProcedureDescriptor)Descriptor).Body);
return(ret);
}
/// <summary>
/// 在自定义数据库连接中根据数据库类型获取数据库连接
/// <example >调用示例
/// <code>
/// yltl.DBUtility.DataBaseOper.GetDataBaseOper(AccessConnectionType.Custom,AccessConnectionType.Oralce,"yltl_192.1680.170","valtagedb_c","","valtagedb_c","123456")
/// </code>
/// 返回：IDataBaseOper
/// </example>
/// 创建者：wls 20090902
/// </summary>
/// <param name="at">数据库的连接方式</param>
/// <param name="at2">自定义数据库的数据库类型</param>
/// <param name="ServerName">(net)服务器名称,或 IP + “，端口号”</param>
/// <param name="DataBaseName">数据库名称</param>
/// <param name="UserIdName">用户</param>
/// <param name="Password">密码</param>
/// <returns></returns>
public static IDataBaseOper GetDataBaseOper(eDBType at, eDBType at2, string ServerName, string DataBaseName, string UserIdName, string Password)
{
switch (at)
{
case eDBType.Access:
case eDBType.Oracle:
case eDBType.SqlServer:
break;
default: //默认是本地库
break;
}
return(null);
}
/// <summary>
/// 转换为数据库的对应参数类型
/// </summary>
/// <param name="dbType"></param>
/// <returns></returns>
public System.Data.Common.DbParameter[] ConvertToDbParameter(eDBType dbType)
{
if (_dicParamNameValue == null | _dicParamNameValue.Count == 0) return new System.Data.Common.DbParameter[0];
System.Data.Common.DbParameter[] pras = new System.Data.Common.DbParameter[_dicParamNameValue.Count];
switch (dbType)
{
case eDBType.Oracle:
System.Data.OracleClient.OracleParameter[] pOras =
new System.Data.OracleClient.OracleParameter[_dicParamNameValue.Count];
int iOra = 0;
foreach (string name in _dicParamNameValue.Keys)
{
pOras[iOra++] = new System.Data.OracleClient.OracleParameter(name, _dicParamNameValue[name]);
}
return pOras;
case eDBType.SqlServer:
System.Data.SqlClient.SqlParameter[] pSqls =
new System.Data.SqlClient.SqlParameter[_dicParamNameValue.Count];
int iSql = 0;
foreach (string name in _dicParamNameValue.Keys)
{
pSqls[iSql++] = new System.Data.SqlClient.SqlParameter(name, _dicParamNameValue[name]);
}
return pSqls;
case eDBType.Access:
System.Data.OleDb.OleDbParameter[] oSqls =
new System.Data.OleDb.OleDbParameter[_dicParamNameValue.Count];
int iOledb = 0;
foreach (string name in _dicParamNameValue.Keys)
{
oSqls[iOledb++] = new System.Data.OleDb.OleDbParameter(name, _dicParamNameValue[name]);
}
return oSqls;
case eDBType.MySql:
case eDBType.DB2:
case eDBType.Sybase:
default:
break;
}
return new System.Data.Common.DbParameter[0];
}
/// <summary>
/// 根据数据库类型获取操作类
/// <example >调用示例
/// <code>
/// yltl.DBUtility.DataBaseOper.GetDataBaseOper(AccessConnectionType.Oralce)
/// </code>
/// 返回：IDataBaseOper
/// </example>
/// 创建者：wls 20090902
/// </summary>
/// <param name="at">数据库类型</param>
/// <returns>DataBaseOper 数据操作类</returns>
public static IDataBaseOper GetDataBaseOper(eDBType dbtype)
{
switch (dbtype)
{
case eDBType.Access:
if (dbOper_Access == null)
{
dbOper_Access = new AccessHelper(dbtype);
}
return(dbOper_Access);
break;
case eDBType.Sybase:
if (dbOper_Sybase == null)
{
dbOper_Sybase = new SybaseHelper(dbtype);
}
return(dbOper_Sybase);
break;
case eDBType.Oracle:
if (dbOper == null)
{
dbOper = new OracleHelper(dbtype);
}
return(dbOper);
break;
break;
case eDBType.SqlServer:
if (dbOper_SqlServer == null)
{
return(dbOper_SqlServer = new SqlServerHelper(dbtype));
}
return(dbOper_SqlServer);
break;
default: //默认是本地库
throw new NotImplementedException("未实现的数据库类型读取:" + dbtype.ToString());
break;
}
return(null);
}
/// <summary>
/// 获取表字段列表
/// </summary>
public Dictionary <string, Type> GetFields(eDBType type, string table_name)
{
Database db = GetDB(type);
if (db == null)
{
return(null);
}
Dictionary <string, Type> ret_list = null;
db.GetFields(table_name, (list) => { ret_list = list; });
return(ret_list);
}
/// <summary>
/// 构造数据库操作类
/// </summary>
/// <param name="at2">数据库类型</param>
/// <param name="ServerName">服务器名称或net服务名</param>
/// <param name="DataBaseName">数据库名称</param>
/// <param name="UserIdName">用户名</param>
/// <param name="Password">密码</param>
public SqlServerHelper(eDBType at2, string ServerName, string DataBaseName, string UserIdName, string Password)
{
switch (at2)
{
case eDBType.SqlServer:
//this.strConntionString = "Provider=SQLOLEDB;server=" + ServerName + ";database=" + DataBaseName + ";uid=" + UserIdName + ";pwd=" + Password + "";
this.strConntionString = "Server=" + ServerName + ";Database=" + DataBaseName + ";Uid=" + UserIdName + ";Pwd=" + Password + "";
break;
case eDBType.Custom:
break;
default:
break;
}
connOpen();
}
private string FillClaims(IDBRevision sender, eDBType dBType)
{
return
(@"
INSERT INTO Common.Claim (ID, Name)
SELECT
a.ID, a.Name
FROM
(
SELECT ID = NEWID(), Name = 'UserManager'
UNION ALL SELECT ID = NEWID(), Name = 'RoleManager'
) a
LEFT JOIN Common.Claim c on a.Name = c.Name
WHERE
c.Name IS NULL
");
}
public override string GetSqlCreate(eDBType dBType)
{
string ret = "";
string errorTryBlock = "";
string errorCatchBlock = "";
if (((DBStoredProcedureDescriptor)Descriptor).ErrorHandling)
{
errorTryBlock = @"BEGIN TRY";
errorCatchBlock =
@"END TRY
BEGIN CATCH
DECLARE @ErrorMessage NVARCHAR(4000);
DECLARE @ErrorSeverity INT;
DECLARE @ErrorState INT;
SELECT
@ErrorMessage = ERROR_MESSAGE(),
@ErrorSeverity = ERROR_SEVERITY(),
@ErrorState = ERROR_STATE();
/*
Do some logging!
*/
SET @ErrorMessage = 'Error handled. ' + @ErrorMessage
RAISERROR (@ErrorMessage, -- Message text.
@ErrorSeverity, -- Severity.
@ErrorState -- State.
);
END CATCH";
}
ret = string.Format(
@"GO
CREATE PROCEDURE {0}.{1}
{2}
AS
{4}
{3}
{5}
", SchemaName, Name, ((DBStoredProcedureDescriptor)Descriptor).Parameters, ((DBStoredProcedureDescriptor)Descriptor).Body, errorTryBlock, errorCatchBlock);
return(ret);
}
/// <summary>
/// 构造数据库操作类
/// </summary>
/// <param name="at2">数据库类型</param>
/// <param name="ServerName">服务器名称或net服务名</param>
/// <param name="DataBaseName">数据库名称</param>
/// <param name="UserIdName">用户名</param>
/// <param name="Password">密码</param>
public SqlServerHelper(eDBType at2, string ServerName, string DataBaseName, string UserIdName, string Password)
{
switch (at2)
{
case eDBType.SqlServer:
//this.strConntionString = "Provider=SQLOLEDB;server=" + ServerName + ";database=" + DataBaseName + ";uid=" + UserIdName + ";pwd=" + Password + "";
this.strConntionString = "Server=" + ServerName + ";Database=" + DataBaseName + ";Uid=" + UserIdName + ";Pwd=" + Password + "";
break;
case eDBType.Custom:
break;
default:
break;
}
connOpen();
}
/// <summary>
/// 通过配置文件的配置来创建数据库连接，可以用来区分同一数据库类型下的多个连接
/// </summary>
/// <param name="dbtype">对应配置中的DBType属性</param>
/// <param name="connectionName">对应配置中的Name属性</param>
/// <returns></returns>
public static IDBOperator CreateByConfig(eDBType dbtype, string connectionName)
{
if (connectionName == null)
{
throw new ArgumentNullException("connectionName", "连接名称不能为null，");
}
var dic = DBConfigDic;
if (dic.ContainsKey(dbtype))
{
if (dic[dbtype].ContainsKey(connectionName))
{
return(Create(dbtype, dic[dbtype][connectionName]));
}
}
throw new Exception(string.Format("在配置中没有找到数据库类型-名称：{0}-{1}", dbtype, connectionName));
}
/// <summary>
/// 在自定义数据库连接中根据数据库类型获取数据库连接
/// <example >调用示例
/// <code>
/// yltl.DBUtility.DataBaseOper.GetDataBaseOper(AccessConnectionType.Custom,AccessConnectionType.Oralce,"yltl_192.1680.170","valtagedb_c","","valtagedb_c","123456")
/// </code>
/// 返回：IDataBaseOper
/// </example>
/// 创建者：wls 20090902
/// </summary>
/// <param name="flag">数据库的连接方式,标示符号 </param>
/// <param name="at">数据库的连接方式</param>
/// <param name="at2">自定义数据库的数据库类型</param>
/// <param name="ServerName">(net)服务器名称</param>
/// <param name="DataBaseName">数据库名称</param>
/// <param name="UserIdName">用户</param>
/// <param name="Password">密码</param>
/// <returns></returns>
public static IDataBaseOper GetDataBaseOper(string flag, eDBType at, eDBType at2, string ServerName, string DataBaseName, string UserIdName, string Password)
{
if (dbOper_Custom_Hashtable == null)
{
dbOper_Custom_Hashtable = new Hashtable();
}
switch (at)
{
case eDBType.Access:
case eDBType.Oracle:
case eDBType.SqlServer:
case eDBType.Sybase:
break;
default: //默认是本地库
break;
}
return(null);
}
/// <summary>
/// �������ݿ����ͻ�ȡ������
/// <example >����ʾ��
/// <code>
/// yltl.DBUtility.DataBaseOper.GetDataBaseOper(AccessConnectionType.Oralce)
/// </code>
/// ���أ�IDataBaseOper
/// </example>
/// �����ߣ�wls 20090902
/// </summary>
/// <param name="at">���ݿ�����</param>
/// <returns>DataBaseOper ���ݲ�����</returns>
public static IDataBaseOper GetDataBaseOper(eDBType dbtype)
{
switch (dbtype)
{
case eDBType.Access:
if (dbOper_Access == null)
{
dbOper_Access = new AccessHelper(dbtype);
}
return dbOper_Access;
break;
case eDBType.Sybase:
if (dbOper_Sybase == null)
{
dbOper_Sybase = new SybaseHelper(dbtype);
}
return dbOper_Sybase;
break;
case eDBType.Oracle:
if (dbOper == null)
{
dbOper = new OracleHelper(dbtype);
}
return dbOper;
break;
break;
case eDBType.SqlServer:
if (dbOper_SqlServer == null)
{
return dbOper_SqlServer = new SqlServerHelper(dbtype);
}
return dbOper_SqlServer;
break;
default: //Ĭ���DZ��ؿ�
throw new NotImplementedException("δʵ�ֵ����ݿ����Ͷ�ȡ:" + dbtype.ToString());
break;
}
return null;
}
private string FillClaims(IDBRevision sender, eDBType dBType)
{
return
(@"WITH ClaimsCTE AS
(
SELECT TOP 0 ID = NEWID(), Name = ''
UNION ALL SELECT ID = NEWID(), Name = 'Routes.HomePage.View'
)
INSERT INTO Common.Claim (ID, Name)
SELECT
claims.ID, claims.Name
FROM
ClaimsCTE claims
LEFT JOIN Common.Claim c ON claims.Name = c.Name
WHERE
c.ID is null
");
}
/// <summary>
/// 根据数据库类型和连接字符串，创建一个数据库操作接口
/// </summary>
/// <param name="dbtype">数据库类型</param>
/// <param name="connectionString">连接字符串</param>
/// <returns></returns>
public static IDBOperator Create(eDBType dbtype, string connectionString)
{
switch (dbtype)
{
case eDBType.Access:
return(new AccessHelper(connectionString));
case eDBType.Oracle:
return(new OracleHelper(connectionString));
case eDBType.SqlServer:
return(new SqlServerHelper(connectionString));
case eDBType.MySql:
case eDBType.DB2:
case eDBType.Sybase:
default:
throw new NotImplementedException("未实现的数据库类型" + dbtype);
}
}
private string FillRoles(IDBRevision sender, eDBType dBType)
{
return
(@"WITH RolesCTE AS
(
SELECT ID = NEWID(), Name = 'Client'
UNION ALL SELECT NEWID(), 'Admin'
UNION ALL SELECT NEWID(), 'BusinessOwner'
)
INSERT INTO Common.Role (ID, Name)
SELECT
t.ID, t.Name
FROM
RolesCTE t
LEFT JOIN Common.Role r ON t.Name = r.Name
WHERE
r.ID is null
");
}
private string FillAdminRolePermissions(IDBRevision sender, eDBType dBType)
{
return
(@"
INSERT INTO Common.Role
SELECT
ID = NEWID(), Name = 'Administrator'
WHERE
NOT EXISTS (SELECT ID FROM Common.Role r WHERE r.Name = 'Administrator')
INSERT INTO Common.RolePermission (ID, ClaimID, RoleID, CanExecute)
SELECT
n.*
FROM
(SELECT ID = NEWID(), ClaimID = c.ID, RoleID = (SELECT ID FROM Common.Role r WHERE r.Name = 'Administrator'), CanExecute = 1 FROM Common.Claim c) n
LEFT JOIN Common.RolePermission rp ON n.ClaimID = rp.ClaimID AND rp.RoleID = n.roleID
WHERE rp.ID is null
");
}
/// <summary>
/// 获取账号id对应的DB
/// </summary>
public static ushort GetDBByAccountIdx(long account_idx, eDBType type)
{
foreach (var obj in db_info.db_list)
{
if (obj.type != (ushort)type)
{
continue;
}
if (obj.account_begin == 0 && obj.account_end == 0)
{
return(obj.id);
}
else if (account_idx >= obj.account_begin && account_idx <= obj.account_end)
{
return(obj.id);
}
}
Log.Warning("未找到账号对应的DB:" + type + " account_idx:" + account_idx);
return(0);
}
internal static void CleanSDT(Artech.Genexus.Common.Objects.Attribute a, IOutputService output, KBObject objRef)
{
if (objRef is SDT)
{
output.AddLine("Cleaning SDT references to " + a.Name + " in " + objRef.Name);
SDTStructurePart sdtstruct = objRef.Parts.Get <SDTStructurePart>();
foreach (IStructureItem structItem in sdtstruct.Root.Items)
{
SDTItem sdtItem = (SDTItem)structItem;
//Esto es para permitir trabajar con Evo3 y la 15.
EntityKey myKey = new EntityKey(a.Key);
#if EVO3
myKey = sdtItem.BasedOn.ObjKey;
#else
myKey = sdtItem.BasedOn.Key;
#endif
//Termina compilacion condicional.
if (sdtItem.BasedOn != null && myKey == a.Key)
{
output.AddLine("..." + sdtItem.Name + " based on " + a.Name);
eDBType type = sdtItem.Type;
int length = sdtItem.Length;
bool signed = sdtItem.Signed;
string desc = sdtItem.Description;
int dec = sdtItem.Decimals;
//Modifico la variable, para que no se base en el atributo.
sdtItem.AttributeBasedOn = null;
sdtItem.Type = type;
sdtItem.Decimals = dec;
sdtItem.Description = desc;
sdtItem.Length = length;
sdtItem.Signed = signed;
}
}
}
}
/// <summary>
/// 根据数据库类型获取操作类
/// </summary>
/// <param name="at">数据库类型</param>
/// <returns>DataBaseOper 数据操作类</returns>
public static SqlServerHelper GetDataBaseOper(eDBType at)
{
switch (at)
{
case eDBType.SqlServer:
if (dbOper_SqlServer == null)
{
return(dbOper_SqlServer = new SqlServerHelper(at));
}
return(dbOper_SqlServer);
break;
case eDBType.Custom:
break;
default:
break;
}
return(null);
}
/// <summary>
/// 在自定义数据库连接中根据数据库类型获取数据库连接
/// </summary>
/// <param name="at">数据库的连接方式</param>
/// <param name="at2">自定义数据库的数据库类型</param>
/// <param name="ServerName">(net)服务器名称</param>
/// <param name="DataBaseName">数据库名称</param>
/// <param name="UserIdName">用户</param>
/// <param name="Password">密码</param>
/// <returns></returns>
public static SybaseHelper GetDataBaseOper(eDBType at, eDBType at2, string ServerName, string DataBaseName, string UserIdName, string Password)
{
switch (at)
{
case eDBType.Access:
case eDBType.Oracle:
case eDBType.SqlServer:
break;
case eDBType.Custom:
if (dbOper_Custom != null)
{
dbOper_Custom.ConnClose(); //先关闭 再连接
}
dbOper_Custom = new SybaseHelper(at2, ServerName, DataBaseName, UserIdName, Password);
return dbOper_Custom;
break;
default: //默认是本地库
break;
}
return null;
}
/// <summary>
/// 根据数据库类型获取操作类
/// </summary>
/// <param name="at">数据库类型</param>
/// <returns>DataBaseOper 数据操作类</returns>
public static SybaseHelper GetDataBaseOper(eDBType at)
{
switch (at)
{
case eDBType.Access:
if (dbOper_Sybase == null)
{
dbOper_Sybase = new SybaseHelper(at);
}
return dbOper_Sybase;
break;
case eDBType.Sybase:
if (dbOper_Sybase == null)
{
dbOper_Sybase = new SybaseHelper(at);
}
return dbOper_Sybase;
break;
case eDBType.Custom:
break;
default: //默认是本地库
if (dbOper_Sybase == null)
{
dbOper_Sybase = new SybaseHelper(at);
}
return dbOper_Sybase;
break;
}
return null;
}
/// <summary>
/// 通过配置文件的配置来创建数据库连接，如果有多个同类型的连接，则只取第一个
/// </summary>
/// <param name="dbtype">对应配置中的DBType属性</param>
/// <returns></returns>
public static IDBOperator CreateByConfig(eDBType dbtype)
{
var dic = DBConfigDic;
if (dic.ContainsKey(dbtype))
{
return Create(dbtype, dic[dbtype].First().Value);
}
throw new Exception("在配置中没有找到数据库类型：" + dbtype);
}
/// <summary>
/// ���Զ������ݿ������и������ݿ����ͻ�ȡ���ݿ�����
/// <example >����ʾ��
/// <code>
/// yltl.DBUtility.DataBaseOper.GetDataBaseOper(AccessConnectionType.Custom,AccessConnectionType.Oralce,"yltl_192.1680.170","valtagedb_c","","valtagedb_c","123456")
/// </code>
/// ���أ�IDataBaseOper
/// </example>
/// �����ߣ�wls 20090902
/// </summary>
/// <param name="at">���ݿ�����ӷ�ʽ</param>
/// <param name="at2">�Զ������ݿ�����ݿ�����</param>
/// <param name="ServerName">(net)����������,�� IP + �����˿ںš�</param>
/// <param name="DataBaseName">���ݿ�����</param>
/// <param name="UserIdName">�û�</param>
/// <param name="Password">����</param>
/// <returns></returns>
public static IDataBaseOper GetDataBaseOper(eDBType at, eDBType at2, string ServerName, string DataBaseName, string UserIdName, string Password)
{
switch (at)
{
case eDBType.Access:
case eDBType.Oracle:
case eDBType.SqlServer:
break;
default: //Ĭ���DZ��ؿ�
break;
}
return null;
}
/// <summary>
/// ���Զ������ݿ������и������ݿ����ͻ�ȡ���ݿ�����
/// <example >����ʾ��
/// <code>
/// yltl.DBUtility.DataBaseOper.GetDataBaseOper(AccessConnectionType.Custom,AccessConnectionType.Oralce,"yltl_192.1680.170","valtagedb_c","","valtagedb_c","123456")
/// </code>
/// ���أ�IDataBaseOper
/// </example>
/// �����ߣ�wls 20090902
/// </summary>
/// <param name="flag">���ݿ�����ӷ�ʽ,��ʾ���� </param>
/// <param name="at">���ݿ�����ӷ�ʽ</param>
/// <param name="at2">�Զ������ݿ�����ݿ�����</param>
/// <param name="ServerName">(net)����������</param>
/// <param name="DataBaseName">���ݿ�����</param>
/// <param name="UserIdName">�û�</param>
/// <param name="Password">����</param>
/// <returns></returns>
public static IDataBaseOper GetDataBaseOper(string flag, eDBType at, eDBType at2, string ServerName, string DataBaseName, string UserIdName, string Password)
{
if (dbOper_Custom_Hashtable == null)
{
dbOper_Custom_Hashtable = new Hashtable();
}
switch (at)
{
case eDBType.Access:
case eDBType.Oracle:
case eDBType.SqlServer:
case eDBType.Sybase:
break;
default: //Ĭ���DZ��ؿ�
break;
}
return null;
}
/// <summary>
/// ���� isNew ���жϣ��Զ��������Ƿ���Ҫ����һ���µ����ӣ�
/// </summary>
/// <param name="isNew">�Ƿ����µ�����</param>
/// <param name="at">���ݿ���������</param>
/// <param name="ServerName">������ ���� DNS������ ODBC����ʱ</param>
/// <param name="DataBaseName">���ݿ����� ODBC����ʱ Ϊ�� ����</param>
/// <param name="UserIdName">�û�</param>
/// <param name="Password">����</param>
/// <returns></returns>
public static IDataBaseOper GetDataBaseOper_BySybaseOleDB(bool isNew, eDBType at, string ServerName, string DataBaseName, string UserIdName, string Password)
{
switch (at)
{
case eDBType.Access:
if (isNew)
{
dbOper_Custom = new AccessHelper(at, ServerName, DataBaseName, UserIdName, Password);
}
else
{
if (dbOper == null)
{
dbOper_Custom = new AccessHelper(at, ServerName, DataBaseName, UserIdName, Password);
}
}
return dbOper_Custom;
break;
case eDBType.Sybase:
if (isNew)
{
dbOper_Custom = new SybaseHelper(at, ServerName, DataBaseName, UserIdName, Password);
}
else
{
if (dbOper_Custom == null)
{
dbOper_Custom = new SybaseHelper(at, ServerName, DataBaseName, UserIdName, Password);
}
}
return dbOper_Custom;
break;
case eDBType.Oracle:
if (isNew)
{
dbOper_Custom = new OracleHelper(at, ServerName, DataBaseName, UserIdName, Password);
}
else
{
if (dbOper_Custom == null)
{
dbOper_Custom = new OracleHelper(at, ServerName, DataBaseName, UserIdName, Password);
}
}
return dbOper_Custom;
break;
case eDBType.SqlServer:
if (isNew)
{
dbOper_Custom = new SqlServerHelper(at, ServerName, DataBaseName, UserIdName, Password);
}
else
{
if (dbOper_Custom == null)
{
dbOper_Custom = new SqlServerHelper(at, ServerName, DataBaseName, UserIdName, Password);
}
}
return dbOper_Custom;
break;
default: //Ĭ���DZ��ؿ�
break;
}
return null;
}
public SqlServerHelper(eDBType at)
{
this.strConntionString = ReadXmlGetConnectString(at.ToString());
connOpen();
}
/// <summary>
/// 构造数据库操作类
/// </summary>
/// <param name="ServerName">服务器名称或net服务名</param>
/// <param name="DataBaseName"></param>
/// <param name="UserIdName"></param>
/// <param name="Password"></param>
public SybaseHelper(eDBType at2, string ServerName, string DataBaseName, string UserIdName, string Password)
{
switch (at2)
{
case eDBType.Access:
//this.strConn = ReadXmlGetConnectString(at.ToString());
break;
case eDBType.Oracle:
//Provider=OraOLEDB.Oracle.1;Persist Security Info=True;User ID=sjy;Password=sjy;Data Source=sjyweb
//this.strConntionString = " Data Source=" + ServerName + ";User ID=" + UserIdName + ";Password="******"";
this.strConntionString = "Provider=OraOLEDB.Oracle.1;Persist Security Info=True;User ID=" + UserIdName + ";Password="******";Data Source=" + ServerName + "";
break;
case eDBType.SqlServer:
this.strConntionString = "Provider=SQLOLEDB;server=" + ServerName + ";database=" + DataBaseName + ";uid=" + UserIdName + ";pwd=" + Password + "";
break;
case eDBType.Custom:
break;
case eDBType.Sybase:
string temp = ReadXmlGetConnectString(at2.ToString());
temp = temp.Replace("DBPWD", Password).Replace("DBUID", UserIdName).Replace("DBDS", ServerName).Replace("DBNAME", DataBaseName);
this.strConntionString = temp;// "Provider=Sybase.ASEOLEDBProvider.2;Data Source=" + ServerName + ";Initial Catalog=" + DataBaseName + ";User ID=" + UserIdName + ";Password="******"";
break;
default:
break;
}
connOpen();
}
/// <summary>
/// 根据数据库类型和连接字符串，创建一个数据库操作接口
/// </summary>
/// <param name="dbtype">数据库类型</param>
/// <param name="connectionString">连接字符串</param>
/// <returns></returns>
public static IDBOperator Create(eDBType dbtype, string connectionString)
{
switch (dbtype)
{
case eDBType.Access:
return new AccessHelper(connectionString);
case eDBType.Oracle:
return new OracleHelper(connectionString);
case eDBType.SqlServer:
return new SqlServerHelper(connectionString);
case eDBType.MySql:
case eDBType.DB2:
case eDBType.Sybase:
default:
throw new NotImplementedException("未实现的数据库类型" + dbtype);
}
}
/// <summary>
/// 根据数据库类型获取操作类
/// </summary>
/// <param name="at">数据库类型</param>
/// <returns>DataBaseOper 数据操作类</returns>
public static SqlServerHelper GetDataBaseOper(eDBType at)
{
switch (at)
{
case eDBType.SqlServer :
if (dbOper_SqlServer == null)
{
return dbOper_SqlServer = new SqlServerHelper(at);
}
return dbOper_SqlServer;
break;
case eDBType.Custom:
break;
default :
break;
}
return null;
}
/// <summary>
/// 通过配置文件的配置来创建数据库连接，可以用来区分同一数据库类型下的多个连接
/// </summary>
/// <param name="dbtype">对应配置中的DBType属性</param>
/// <param name="connectionName">对应配置中的Name属性</param>
/// <returns></returns>
public static IDBOperator CreateByConfig(eDBType dbtype, string connectionName)
{
if (connectionName == null) throw new ArgumentNullException("connectionName", "连接名称不能为null，");
var dic = DBConfigDic;
if (dic.ContainsKey(dbtype))
{
if (dic[dbtype].ContainsKey(connectionName))
{
return Create(dbtype, dic[dbtype][connectionName]);
}
}
throw new Exception(string.Format("在配置中没有找到数据库类型-名称：{0}-{1}", dbtype, connectionName));
}
