public FrmTableView(IDbClass dbClass,ITableClass table,string parentTitle=null)
{
InitializeComponent();
_dbClass = dbClass;
_table = table;
this.Text += "【" + _table.TableName + "】- " + parentTitle;
}
public FrmNormalView(IDbClass dbClass, object obj, string text)
{
InitializeComponent();
_dbClass = dbClass;
_object = obj;
this.Text = text;
}
public FrmTableView(IDbClass dbClass, ITableClass table, string parentTitle = null)
{
InitializeComponent();
_dbClass = dbClass;
_table = table;
this.Text += "【" + _table.TableName + "】- " + parentTitle;
}
public FrmNormalView(IDbClass dbClass,object obj,string text)
{
InitializeComponent();
_dbClass = dbClass;
_object = obj;
this.Text = text;
}
private void CloseDb()
{
if (_dbClass != null)
{
_dbClass.Close();
_dbClass = null;
}
}
public void SetDbClass(IDbClass dbClass)
{
_dbClass = dbClass;
ClearData();
if (_dbClass == null)
{
return;
}
}
public static IDbClass GetDbClass(string connectstring, MyDbType type)
{
IDbClass dbClass = null;
IDbSelector selector = GetDbSelector(type);
if (selector != null)
{
dbClass = selector.GetDbClass(connectstring);
}
return(dbClass);
}
//IDbClass<T> IDbSet<T>.DbClass => this.DbClass as IDbClass<T>;
public SQLBag(Database db, IDbClass <T> dbCls)
{
this.Database = db;
this.DbClass = dbCls;
InternalSqls = new ConcurrentDictionary <string, SQLs.SQL <T> >();
this.AllFieldsSql = new SQLs.SQL <T>(string.Empty, this);
//this.FieldedSqls.TryAdd(null,this.Sql);
this.InternalSqls.TryAdd("", this.AllFieldsSql);
this.InternalSqls.TryAdd("*", this.AllFieldsSql);
}
public IDbClass GetDbClass()
{
IDbClass dbClass = null;
string connectString = GetConnectString();
dbClass = MyDbHelper.GetDbClass(connectString, dbType);
if (dbClass != null)
{
dbClass.Open();
}
return(dbClass);
}
private void btnConnect_Click(object sender, EventArgs e)
{
if (!CheckInput())
{
return;
}
try
{
_dbClass = this.DbConnectConfigure.GetDbClass();
this.DialogResult = DialogResult.OK;
this.Close();
}
catch (System.Exception ex)
{
MessageBox.Show("打开数据库失败！" + ex.Message);
}
}
public SQL(string membersString, Database db, IDbClass dbClass)
{
this.Database = db;
this.DbSettings = db.Settings;
this.DbTrait = db.Trait;
this.DbClass = dbClass;
this.FieldedProps = this.DbClass.FieldedProps;
this.MembersString = membersString ?? string.Empty;
if (string.IsNullOrEmpty(this.MembersString) || this.MembersString == "*")
{
this._AllowedProps = this.DbClass.FieldedProps;
this.MembersString = "*";
}
else
{
var memberNames = MembersString.Split(',');
var props = new Dictionary <string, IDbProperty>();
_AllowedProps = props;
foreach (var mName in memberNames)
{
var memName = mName.Trim();
IDbProperty prop = null;
if (this.DbClass.FieldedProps.TryGetValue(memName, out prop))
{
props.Add(prop.Field.Name, prop);
}
}
}
this.Create = new Create <T>(this);
this.Insert = new Insert <T>(this);
//this.Update = new Update(model, membersString);
//this.Select = new Select(model, membersString);
}
public FrmDatabase(IDbClass dbClass)
{
InitializeComponent();
SetDbClass(dbClass);
}
private void btnConnect_Click(object sender, EventArgs e)
{
if (!CheckInput())
{
return;
}
try
{
_dbClass = this.DbConnectConfigure.GetDbClass();
this.DialogResult = DialogResult.OK;
this.Close();
}
catch (System.Exception ex)
{
MessageBox.Show("打开数据库失败！"+ex.Message);
}
}
public Server()
{
Sem = new SemaphoreSlim(0);
DBClass = new DataBaseContext();
listener = new HttpListener();
}
public FrmExportDbt(IDbClass dbclass)
{
InitializeComponent();
_dbClass = dbclass;
}
public FrmDatabase(IDbClass dbClass)
{
InitializeComponent();
SetDbClass(dbClass);
}
public void SetDbClass(IDbClass dbClass)
{
CloseDb();
_dbClass = dbClass;
}
public FrmImportDbt(IDbClass dbClass)
{
InitializeComponent();
_dbClass = dbClass;
ReadToDbAction = new DbTFileReader.ReadToDbExceptionHandle(DoReadToDbException);
}
public FrmImportDbt(IDbClass dbClass)
{
InitializeComponent();
_dbClass = dbClass;
ReadToDbAction = new DbTFileReader.ReadToDbExceptionHandle(DoReadToDbException);
}
public void WriteDb(IDbClass dbClass, DbClassSelected selected)
{
SetPro(0, "开始导出数据库类型...");
BeginWrite(DbtFileTags.DbTFile);
//写入类型
BeginWrite(DbtFileTags.DbType);
Write(dbClass.GetClassDbType());
EndWrite(DbtFileTags.DbType);
BeginWrite(DbtFileTags.Version);
Write(dbClass.GetDbVersionString());
EndWrite(DbtFileTags.Version);
SetPro(2, "导出数据库类型结束！");
if (selected.isTablesChecked)
{
SetPro(2, "开始获取表...");
//写入表
List <ITableClass> tables = dbClass.GetTables();
SetPro(10, "获取表个数：" + tables.Count);
if (tables.Count > 0)
{
SetPro(10, "开始导出表...");
BeginWrite(DbtFileTags.Tables);
foreach (ITableClass item in tables)
{
SetPro(15, "开始导出表:" + item.TableName);
BeginWrite(DbtFileTags.Table);
Write(item);
EndWrite(DbtFileTags.Table);
}
EndWrite(DbtFileTags.Tables);
SetPro(25, "导出表结束！");
}
}
SetPro(25, "");
if (selected.isConstraintsChecked)
{
SetPro(25, "开始获取约束...");
//写入约束
List <IConstraintClass> conss = dbClass.GetConstraints();
SetPro(28, "获取约束个数：" + conss.Count);
if (conss.Count > 0)
{
SetPro(28, "开始导出约束...");
BeginWrite(DbtFileTags.Constraints);
foreach (IConstraintClass item in conss)
{
SetPro(30, "导出约束:" + item.Name);
BeginWrite(DbtFileTags.Constraint);
Write(item);
EndWrite(DbtFileTags.Constraint);
}
EndWrite(DbtFileTags.Constraints);
SetPro(35, "导出约束结束！");
}
}
SetPro(35, "");
if (selected.isSequencesChecked)
{
SetPro(35, "开始获取序列...");
//写入序列
List <ISequenceClass> seqs = dbClass.GetSequences();
SetPro(37, "获取序列个数：" + seqs.Count);
if (seqs.Count > 0)
{
SetPro(37, "开始导出序列...");
BeginWrite(DbtFileTags.Sequences);
foreach (ISequenceClass item in seqs)
{
SetPro(39, "导出序列:" + item.SequenceName);
BeginWrite(DbtFileTags.Sequence);
Write(item);
EndWrite(DbtFileTags.Sequence);
}
EndWrite(DbtFileTags.Sequences);
SetPro(40, "结束导出序列.");
}
}
SetPro(40, "");
if (selected.isTriggersChecked)
{
SetPro(40, "开始获取触发器...");
//写入触发器
List <ITriggerClass> tris = dbClass.GetTriggers();
SetPro(41, "获取触发器个数：" + tris.Count);
if (tris.Count > 0)
{
SetPro(41, "开始导出触发器...");
BeginWrite(DbtFileTags.Triggers);
foreach (ITriggerClass item in tris)
{
SetPro(43, "开始导出触发器...");
BeginWrite(DbtFileTags.Trigger);
Write(item);
EndWrite(DbtFileTags.Trigger);
}
EndWrite(DbtFileTags.Triggers);
SetPro(44, "结束导出触发器.");
}
}
SetPro(44, "");
if (selected.isIndexesChecked)
{
SetPro(44, "开始获取索引...");
//写入索引
List <IIndexClass> inds = dbClass.GetIndexs();
SetPro(45, "获取索引个数：" + inds.Count);
if (inds.Count > 0)
{
SetPro(45, "开始导出索引...");
BeginWrite(DbtFileTags.Indexes);
foreach (IIndexClass item in inds)
{
SetPro(46, "导出索引:" + item.Name);
BeginWrite(DbtFileTags.Index);
Write(item);
EndWrite(DbtFileTags.Index);
}
EndWrite(DbtFileTags.Indexes);
SetPro(47, "导出索引结束.");
}
}
SetPro(47, "");
if (selected.isFunctionsChecked)
{
SetPro(47, "开始获取函数...");
//写入函数
List <IFunctionClass> funs = dbClass.GetFunctions();
SetPro(48, "获取函数个数：" + funs.Count);
if (funs.Count > 0)
{
SetPro(48, "开始导出函数...");
BeginWrite(DbtFileTags.Functions);
foreach (IFunctionClass item in funs)
{
SetPro(49, "导出函数:" + item.Name);
BeginWrite(DbtFileTags.Function);
Write(item);
EndWrite(DbtFileTags.Function);
}
EndWrite(DbtFileTags.Functions);
SetPro(50, "导出函数结束.");
}
}
SetPro(50, "");
if (selected.isProceduresChecked)
{
SetPro(50, "开始获取过程...");
//写入过程
List <IProcedureClass> pros = dbClass.GetProcedures();
SetPro(51, "获取过程个数：" + pros.Count);
if (pros.Count > 0)
{
SetPro(51, "开始导出过程...");
BeginWrite(DbtFileTags.Procedures);
foreach (IProcedureClass item in pros)
{
SetPro(51, "导出过程:" + item.Name);
BeginWrite(DbtFileTags.Procedure);
Write(item);
EndWrite(DbtFileTags.Procedure);
}
EndWrite(DbtFileTags.Procedures);
SetPro(52, "导出过程结束.");
}
}
SetPro(52, "");
if (selected.isJavaSourcesChecked)
{
SetPro(52, "开始获取java资源...");
//写入Java资源
List <IJavaSourceClass> javas = dbClass.GetJavaSources();
SetPro(53, "获取java资源个数：" + javas.Count);
if (javas.Count > 0)
{
SetPro(53, "开始导出java资源...");
BeginWrite(DbtFileTags.JavaSources);
foreach (IJavaSourceClass item in javas)
{
SetPro(53, "导出java资源:" + item.Name);
BeginWrite(DbtFileTags.JavaSource);
Write(item);
EndWrite(DbtFileTags.JavaSource);
}
EndWrite(DbtFileTags.JavaSources);
SetPro(54, "导出java资源结束.");
}
}
SetPro(54, "");
int perleft = 100 - 54;
if (selected.isDatasChecked)
{
SetPro(54, "开始导出数据...");
//写入数据
List <ITableClass> tables = dbClass.GetTables();
if (tables.Count > 0)
{
float dper = perleft / (float)tables.Count;
int tcount = 0;
BeginWrite(DbtFileTags.Datas);
foreach (ITableClass item in tables)
{
tcount++;
decimal totalDataCount = dbClass.GetTableDataCount(item.TableName);
SetPro(54 + (int)(tcount * dper), "开始导出表:" + item.TableName + " 的数据...，需导出总数:" + totalDataCount);
if (totalDataCount == 0)
{
SetPro(-1, "表 " + item.TableName + " 无数据导出！");
continue;
}
List <DbData> list = dbClass.GetTableData(item.TableName, 0, 50);
if (list.Count > 0)
{
BeginWrite(DbtFileTags.Data);
BeginWrite(DbtFileTags.DataTableName);
Write(list[0].TableDataRow.tableName);
EndWrite(DbtFileTags.DataTableName);
BeginWrite(DbtFileTags.DataColumnType);
Write(list[0].TableDataRow.tableColumnTypes);
EndWrite(DbtFileTags.DataColumnType);
BeginWrite(DbtFileTags.DataColumnDbType);
Write(list[0].TableDataRow.tableColumnDbTypes);
EndWrite(DbtFileTags.DataColumnDbType);
BeginWrite(DbtFileTags.DataCulumnName);
Write(list[0].TableDataRow.tableColumnNames);
EndWrite(DbtFileTags.DataCulumnName);
BeginWrite(DbtFileTags.DataCount);
Write(totalDataCount);
EndWrite(DbtFileTags.DataCount);
int start = 0;
do
{
foreach (DbData data in list)
{
BeginWrite(DbtFileTags.DataValue);
Write(data.TableDataRow.base64TableValues);
EndWrite(DbtFileTags.DataValue);
}
if (list.Count != 50)
{
SetPro(54 + (int)(tcount * dper), "导出表:" + item.TableName + " 的数据个数为：" + (start + list.Count));
break;
}
else
{
start += 50;
list = dbClass.GetTableData(item.TableName, start, 50);
}
} while (true);
EndWrite(DbtFileTags.Data);
}
}
EndWrite(DbtFileTags.Datas);
}
}
EndWrite(DbtFileTags.DbTFile);
SetPro(100, "导出结束.");
}
public FrmExportDbt(IDbClass dbclass)
{
InitializeComponent();
_dbClass = dbclass;
}
public FrmSqlWin(IDbClass dbClass)
{
InitializeComponent();
_dbClass = dbClass;
dataView.DbClass = _dbClass;
}
public FrmSqlWin(IDbClass dbClass)
{
InitializeComponent();
_dbClass = dbClass;
dataView.DbClass = _dbClass;
}
public void ReadToDb(IDbClass dbClass, ReadToDbExceptionHandle exceptionHandle = null,
bool isReadTables = true,
bool isReadConstraints = true,
bool isReadSequences = true,
bool isReadTriggers = true,
bool isReadIndexes = true,
bool isReadFunctions = true,
bool isReadProcedures = true,
bool isReadJavaSources = true,
bool isReadDatas = true)
{
int process_start = 0;
int process_end = 3;
#region 配置文件打开预加载
SetPro(process_start, "开始导入数据库文件...");
if (_dbtFile == null)
{
SetPro(100, "数据库配置不正确！");
return;
}
process_start = 1;
SetPro(process_start, "数据库配置：" + _dbtFile.ToString());
if (_dbDefine == null)
{
SetPro(process_start, "开始读取数据库文件定义...");
ReadDbDefinition();
}
process_start = 2;
SetPro(process_start);
if (_dbDefine == null)
{
SetPro(100, "数据库文件定义不正确！");
return;
}
#endregion
SetPro(process_end, "读取到数据库定义:" + _dbDefine.ToString());
process_start = process_end;
process_end = 4;
#region 获取当前表空间
SetPro(process_start, "开始获取当前表空间...");
string tableSpaceName = null;
try
{
tableSpaceName = dbClass.GetCurrentTableSpaceName();
}
catch (Exception ex)
{
if (!DoProToDbException("读取表空间异常", exceptionHandle, ex))
{
return;
}
}
SetPro(process_end, "获取到当前表空间:" + tableSpaceName);
#endregion
SetPro(process_end);
process_start = process_end;
process_end = 20;
#region 导入表
if (isReadTables)
{
SetPro(process_start, "待导入表的数目:" + _dbDefine.Tables.Count);
if (_dbDefine.Tables.Count > 0)
{
SetPro(process_start, "开始导入表定义...");
float dd = (process_end - process_start) / (float)_dbDefine.Tables.Count;
int dtcount = 0;
foreach (ITableClass item in _dbDefine.Tables)
{
dtcount++;
int pro = process_start + (int)(dtcount * dd);
SetPro(pro, "开始导入表:" + item.TableName);
CreateSqlDelegate action = MyDbHelper.GetCreateSqlFunction(item, dbClass.GetClassDbType());
List <CreateSqlObject> sqlObjs = action(tableSpaceName);
foreach (CreateSqlObject sql in sqlObjs)
{
try
{
dbClass.GetDbHelper().ExecuteSql(sql.sql);
}
catch (System.Exception ex)
{
if (!DoProToDbException("导入表错误", exceptionHandle, ex, "执行的SQL:" + sql.sql))
{
return;
}
}
}
}
}
}
#endregion
SetPro(process_end);
process_start = process_end;
process_end = 60;
#region 导入数据
if (isReadDatas)
{
DbData data = this.GetNextDataRow();
int tablesCount = _dbDefine.Tables.Count == 0 ? 1 : _dbDefine.Tables.Count;
float dd = (process_end - process_start) / (float)tablesCount;
int dtcount = 0;
if (data != null)
{
SetPro(20, "开始导入数据...");
int count = -1;
string tablename = null;
while (data != null)
{
if (count == -1)
{
int add = (int)(dtcount * dd);
if (add > process_end)
{
add = process_end;
}
dtcount++;
tablename = data.TableDataRow.tableName;
SetPro(process_start + add, "开始导入表：" + tablename + " 的数据...待导入数目:" + curTableDataCount);
count = 0;
}
else if (data.TableDataRow.tableName != tablename)
{
int add = (int)(dtcount * dd);
if (add > process_end)
{
add = process_end;
}
SetPro(process_start + add, "导入表：" + tablename + " 的数据个数为：" + count);
tablename = data.TableDataRow.tableName;
SetPro(process_start + add, "开始导入表：" + tablename + " 的数据...待导入数目:" + curTableDataCount);
count = 0;
dtcount++;
}
CreateDataSqlDelegate action = MyDbHelper.GetCreateSqlFunction(data, dbClass.GetClassDbType());
CreateDataSqlParams sqlpram = action();
try
{
dbClass.GetDbHelper().ExecuteSql(sqlpram.sql, sqlpram.sql_params);
}
catch (Exception ex)
{
if (!DoProToDbException("导入数据错误", exceptionHandle, ex, "执行的SQL:" + sqlpram.sql + "\r\n数据：" + Newtonsoft.Json.JsonConvert.SerializeObject(data.TableDataRow.base64TableValues)))
{
return;
}
}
count++;
data = this.GetNextDataRow();
}
SetPro(process_end, "导入表：" + tablename + " 的数据个数为：" + count);
SetPro(process_end, "导入数据结束.");
}
}
#endregion
SetPro(process_end);
process_start = process_end;
process_end = 70;
#region 导入索引
if (isReadIndexes)
{
SetPro(process_start, "待导入索引个数：" + _dbDefine.Indexes.Count);
if (_dbDefine.Indexes.Count > 0)
{
SetPro(process_start, "开始导入索引...");
float dd = (process_end - process_start) / (float)_dbDefine.Indexes.Count;
int dtcount = 0;
foreach (IIndexClass item in _dbDefine.Indexes)
{
dtcount++;
SetPro(process_start + (int)(dtcount * dd), "开始导入表:" + item.Table_Name + " 的索引:" + item.Name);
CreateSqlDelegate action = MyDbHelper.GetCreateSqlFunction(item, dbClass.GetClassDbType());
List <CreateSqlObject> sqlObjs = action(tableSpaceName);
foreach (CreateSqlObject sql in sqlObjs)
{
try
{
dbClass.GetDbHelper().ExecuteSql(sql.sql);
}
catch (System.Exception ex)
{
if (!DoProToDbException("导入索引错误", exceptionHandle, ex, "执行的SQL:" + sql.sql))
{
return;
}
}
}
}
SetPro(process_end, "导入索引结束.");
}
}
#endregion
SetPro(process_end);
process_start = process_end;
process_end = 80;
#region 导入约束
if (isReadConstraints)
{
SetPro(process_start, "待导入表的约束个数：" + _dbDefine.Constraints.Count);
if (_dbDefine.Constraints.Count > 0)
{
SetPro(process_start, "开始导入表约束...");
float dd = (process_end - process_start) / (float)_dbDefine.Constraints.Count;
int dtcount = 0;
IOrderedEnumerable <IConstraintClass> ordered = _dbDefine.Constraints.OrderBy(m => m.Level);
foreach (IConstraintClass item in ordered)
{
dtcount++;
int pro = process_start + (int)(dtcount * dd);
SetPro(pro, "开始导入表:" + item.Table_Name + " 的约束:" + item.Name);
CreateSqlDelegate action = MyDbHelper.GetCreateSqlFunction(item, dbClass.GetClassDbType());
List <CreateSqlObject> sqlObjs = action(tableSpaceName);
foreach (CreateSqlObject sql in sqlObjs)
{
try
{
dbClass.GetDbHelper().ExecuteSql(sql.sql);
}
catch (System.Exception ex)
{
if (!DoProToDbException("导入约束错误", exceptionHandle, ex, "执行的SQL:" + sql.sql))
{
return;
}
}
}
}
SetPro(process_end, "导入约束结束.");
}
}
#endregion
SetPro(process_end);
process_start = process_end;
process_end = 85;
#region 导入序列
if (isReadSequences)
{
SetPro(process_start, "待导入序列个数：" + _dbDefine.Sequences.Count);
if (_dbDefine.Sequences.Count > 0)
{
SetPro(process_start, "开始导入序列...");
float dd = (process_end - process_start) / (float)_dbDefine.Sequences.Count;
int dtcount = 0;
foreach (ISequenceClass item in _dbDefine.Sequences)
{
dtcount++;
SetPro(process_start + (int)(dtcount * dd), "开始导入序列:" + item.SequenceName);
CreateSqlDelegate action = MyDbHelper.GetCreateSqlFunction(item, dbClass.GetClassDbType());
List <CreateSqlObject> sqlObjs = action(tableSpaceName);
foreach (CreateSqlObject sql in sqlObjs)
{
try
{
dbClass.GetDbHelper().ExecuteSql(sql.sql);
}
catch (Exception ex)
{
if (!DoProToDbException("导入序列错误", exceptionHandle, ex, "执行的SQL:" + sql.sql))
{
return;
}
}
}
}
SetPro(process_end, "导入序列结束.");
}
}
#endregion
SetPro(process_end);
process_start = process_end;
process_end = 90;
#region 导入触发器
if (isReadTriggers)
{
SetPro(process_start, "待导入触发器个数：" + _dbDefine.Triggers.Count);
if (_dbDefine.Triggers.Count > 0)
{
float dd = (process_end - process_start) / (float)_dbDefine.Triggers.Count;
int dtcount = 0;
SetPro(80, "开始导入触发器...");
foreach (ITriggerClass item in _dbDefine.Triggers)
{
dtcount++;
SetPro(process_start + (int)(dtcount * dd), "开始导入表:" + item.Table_Name + " 的触发器:" + item.Name);
CreateSqlDelegate action = MyDbHelper.GetCreateSqlFunction(item, dbClass.GetClassDbType());
List <CreateSqlObject> sqlObjs = action(tableSpaceName);
foreach (CreateSqlObject sql in sqlObjs)
{
try
{
dbClass.GetDbHelper().ExecuteSql(sql.sql);
}
catch (System.Exception ex)
{
if (!DoProToDbException("导入触发器错误", exceptionHandle, ex, "执行的SQL:" + sql.sql))
{
return;
}
}
}
}
}
SetPro(process_end, "导入触发器结束.");
}
#endregion
SetPro(process_end);
process_start = process_end;
process_end = 95;
#region 导入过程
if (isReadProcedures)
{
SetPro(process_start, "待导入存储过程个数：" + _dbDefine.Procedures.Count);
if (_dbDefine.Procedures.Count > 0)
{
float dd = (process_end - process_start) / (float)_dbDefine.Procedures.Count;
int dtcount = 0;
SetPro(process_start, "开始导入存储过程...");
foreach (IProcedureClass item in _dbDefine.Procedures)
{
dtcount++;
SetPro(process_start + (int)(dtcount * dd), "开始导入存储过程:" + item.Name);
CreateSqlDelegate action = MyDbHelper.GetCreateSqlFunction(item, dbClass.GetClassDbType());
List <CreateSqlObject> sqlObjs = action(tableSpaceName);
foreach (CreateSqlObject sql in sqlObjs)
{
try
{
dbClass.GetDbHelper().ExecuteSql(sql.sql);
}
catch (System.Exception ex)
{
if (!DoProToDbException("导入存储过程错误", exceptionHandle, ex, "执行的SQL:" + sql.sql))
{
return;
}
}
}
}
SetPro(process_end, "导入过程结束.");
}
}
#endregion
SetPro(process_end);
process_start = process_end;
process_end = 97;
#region 导入函数
if (isReadFunctions)
{
SetPro(process_start, "待导入函数个数：" + _dbDefine.Functions.Count);
if (_dbDefine.Functions.Count > 0)
{
float dd = (process_end - process_start) / (float)_dbDefine.Functions.Count;
int dtcount = 0;
SetPro(process_start, "开始导入函数...");
foreach (IFunctionClass item in _dbDefine.Functions)
{
dtcount++;
SetPro(process_start + (int)(dtcount * dd), "开始导入函数:" + item.Name);
CreateSqlDelegate action = MyDbHelper.GetCreateSqlFunction(item, dbClass.GetClassDbType());
List <CreateSqlObject> sqlObjs = action(tableSpaceName);
foreach (CreateSqlObject sql in sqlObjs)
{
try
{
dbClass.GetDbHelper().ExecuteSql(sql.sql);
}
catch (System.Exception ex)
{
if (!DoProToDbException("导入函数错误", exceptionHandle, ex, "执行的SQL:" + sql.sql))
{
return;
}
}
}
}
SetPro(process_end, "导入函数结束.");
}
}
#endregion
SetPro(process_end);
process_start = process_end;
process_end = 100;
#region 导入java资源
if (isReadJavaSources)
{
SetPro(process_start, "待导入Java资源个数：" + _dbDefine.JavaSources.Count);
if (_dbDefine.JavaSources.Count > 0)
{
float dd = (process_end - process_start) / (float)_dbDefine.JavaSources.Count;
int dtcount = 0;
SetPro(95, "开始导入Java资源...");
foreach (IJavaSourceClass item in _dbDefine.JavaSources)
{
dtcount++;
SetPro(95 + (int)(dtcount * dd), "开始导入java资源:" + item.Name);
CreateSqlDelegate action = MyDbHelper.GetCreateSqlFunction(item, dbClass.GetClassDbType());
List <CreateSqlObject> sqlObjs = action(tableSpaceName);
foreach (CreateSqlObject sql in sqlObjs)
{
try
{
dbClass.GetDbHelper().ExecuteSql(sql.sql);
}
catch (System.Exception ex)
{
if (!DoProToDbException("导入Java资源错误", exceptionHandle, ex, "执行的SQL:" + sql.sql))
{
return;
}
}
}
}
SetPro(process_end, "导入Java资源结束.");
}
}
#endregion
SetPro(process_end, "导入结束.");
}
