protected string GetProcName(SqlStatementType statementType)
{
switch (statementType)
{
case SqlStatementType.Select:
return(string.Format(FetchCommandFormat, SourceTable.Name));
case SqlStatementType.SelectBy:
if (ParentTable == null)
{
throw new InvalidOperationException("ParentTable must be specified for SelectBy procs.");
}
return(string.Format(FetchByCommandFormat, SourceTable.Name, ParentTable.Name));
case SqlStatementType.Insert:
return(string.Format(InsertCommandFormat, SourceTable.Name));
case SqlStatementType.Update:
return(string.Format(UpdateCommandFormat, SourceTable.Name));
case SqlStatementType.Delete:
return(string.Format(DeleteCommandFormat, SourceTable.Name));
default:
throw new ArgumentOutOfRangeException("statementType", statementType.ToString(), "No command format has been defined for this SqlStatementType");
}
}
public CommandExecutedEventArgs(FbDataReader dataReader, string commandText, SqlStatementType statementType, int rowsAffected)
{
DataReader = dataReader;
CommandText = commandText;
StatementType = statementType;
RowsAffected = rowsAffected;
}
/// <summary>
/// Create new Store proc parameter.
/// </summary>
/// <param name="paramName">Sql parameter name.</param>
/// <param name="paramType"><see cref="SqlDbType"/> parameter type.</param>
/// <param name="size"><see cref="Int32"/> sql parameter size - use with string.</param>
/// <param name="usedFor">Array of <see cref="SqlStatementType"/> values to determine the SP usage.</param>
internal StoredProcParameter(string paramName,
SqlDbType paramType,
int size,
SqlStatementType[] usedFor)
: this(new SqlParameter(paramName, paramType, size), usedFor)
{
}
public CommandExecutedEventArgs(FbDataReader dataReader, string commandText, SqlStatementType statementType, int rowsAffected)
{
DataReader = dataReader;
CommandText = commandText;
StatementType = statementType;
RowsAffected = rowsAffected;
}
protected string GetTableTimeStampSelect(SqlStatementType statementType, int indentLevel)
{
StringBuilder select = new StringBuilder(Indent(indentLevel, true));
select.Append(SelectStatementTemplate);
select.Replace("[SELECTCOLUMNS]", string.Format("SELECT @New{0} = {0}", TimeStampColumn));
select.Replace("[FROM]", string.Format("FROM {0}", SourceTable.Name));
string parameterName;
StringBuilder where = new StringBuilder("WHERE ");
foreach (ColumnSchema column in SourceTable.PrimaryKey.MemberColumns)
{
if (SourceTable.PrimaryKey.MemberColumns.IndexOf(column) > 0)
{
where.Append(" AND ");
}
if (statementType == SqlStatementType.Insert && IsIdentity(column))
{
parameterName = string.Format("@New{0}", column.Name);
}
else
{
parameterName = string.Format("@{0}", column.Name);
}
where.Append(string.Format("{0} = {1}", column.Name, parameterName));
}
select.Replace("[WHERE]", where.ToString());
return(select.ToString());
}
/// <summary>
/// Create new Store proc parameter.
/// </summary>
/// <param name="paramName">Sql parameter name.</param>
/// <param name="paramType"><see cref="SqlDbType"/> parameter type.</param>
/// <param name="paramSize"><see cref="Int32"/> sql parameter size - use with string.</param>
/// <param name="usedFor1">Identifies the purpose of the parameter.</param>
internal StoredProcParameter(string paramName,
SqlDbType paramType,
int paramSize,
SqlStatementType usedFor1)
: this(paramName, paramType, paramSize, new[] {usedFor1})
{
}
/// <summary>
/// Gets the corresponding <see cref="SqlStatementType"/> for a SQL statement.
/// </summary>
/// <param name="sqlStatement">The SQL statement.</param>
/// <returns>Type of operation done against the database server by the given statement.</returns>
public static SqlStatementType GetSqlStatementType(string sqlStatement)
{
if (string.IsNullOrEmpty(sqlStatement))
{
return(SqlStatementType.None);
}
SqlStatementType statementType = SqlStatementType.Other;
sqlStatement = sqlStatement.TrimStart().ToUpperInvariant();
if (sqlStatement.StartsWith(STATEMENT_UPDATE))
{
statementType = SqlStatementType.Update;
}
else if (sqlStatement.StartsWith(STATEMENT_INSERT))
{
statementType = SqlStatementType.Insert;
}
else if (sqlStatement.StartsWith(STATEMENT_DELETE))
{
statementType = SqlStatementType.Delete;
}
else if (sqlStatement.StartsWith(STATEMENT_SET_GLOBAL))
{
statementType = SqlStatementType.SetGlobal;
}
else if (sqlStatement.StartsWith(STATEMENT_SET))
{
statementType = SqlStatementType.Set;
}
else if (sqlStatement.StartsWith(STATEMENT_CREATE_TABLE))
{
statementType = SqlStatementType.CreateTable;
}
else if (sqlStatement.StartsWith(STATEMENT_CREATE_SCHEMA))
{
statementType = SqlStatementType.CreateSchema;
}
else if (sqlStatement.StartsWith(STATEMENT_ALTER_TABLE))
{
statementType = SqlStatementType.AlterTable;
}
else if (sqlStatement.StartsWith(STATEMENT_LOCK_TABLES))
{
statementType = SqlStatementType.LockTables;
}
else if (sqlStatement.StartsWith(STATEMENT_UNLOCK_TABLES))
{
statementType = SqlStatementType.UnlockTables;
}
else if (sqlStatement.StartsWith(STATEMENT_GRANT_ALL))
{
statementType = SqlStatementType.GrantAll;
}
return(statementType);
}
// logging ////////////////////////////////////////////////
protected internal virtual void logStatement(SqlStatementType type, object parameters, string statement, long duration)
{
IList <SqlStatementLog> log = threadStatementLog.get();
if (log != null)
{
log.Add(new SqlStatementLog(type, parameters, statement, duration));
}
}
//JAVA TO C# CONVERTER TODO TASK: Most Java annotations will not have direct .NET equivalent attributes:
//ORIGINAL LINE: @SuppressWarnings("unchecked") protected void processResults(org.camunda.bpm.qa.performance.engine.framework.PerfTestResults results, TabularResultSet tabularResultSet)
protected internal override void processResults(PerfTestResults results, TabularResultSet tabularResultSet)
{
List <object> row = new List <object>();
row.Add(results.TestName);
int insertCount = 0;
int deleteCount = 0;
int updateCount = 0;
int selectCount = 0;
if (results.PassResults.Count == 0)
{
return;
}
IList <PerfTestStepResult> stepResults = results.PassResults[0].StepResults;
foreach (PerfTestStepResult stepResult in stepResults)
{
IList <LinkedHashMap <string, string> > statementLogs = (IList <LinkedHashMap <string, string> >)stepResult.ResultData;
foreach (LinkedHashMap <string, string> statementLog in statementLogs)
{
string type = statementLog.get("statementType");
SqlStatementType statementType = Enum.Parse(typeof(SqlStatementType), type);
switch (statementType)
{
case SqlStatementType.DELETE:
deleteCount++;
break;
case SqlStatementType.INSERT:
insertCount++;
break;
case SqlStatementType.UPDATE:
updateCount++;
break;
default:
selectCount++;
break;
}
}
}
row.Add(insertCount);
row.Add(deleteCount);
row.Add(updateCount);
row.Add(selectCount);
tabularResultSet.addResultRow(row);
}
protected string GetProcCreateStatement(string procName, SqlStatementType statementType,
int indentLevel)
{
StringBuilder sb = new StringBuilder();
sb.Append(Indent(indentLevel, true));
sb.Append("CREATE PROCEDURE ");
sb.Append(procName);
sb.Append(Indent(indentLevel++, true));
sb.Append("(");
ColumnSchemaCollection columns;
bool ignoreAutoSetColumns = true;
switch (statementType)
{
case SqlStatementType.Insert:
case SqlStatementType.Update:
columns = SourceTable.Columns;
ignoreAutoSetColumns = false;
break;
case SqlStatementType.SelectBy:
CheckForPrimaryKey(ParentTable);
columns = ParentTable.PrimaryKey.MemberColumns;
break;
default:
CheckForPrimaryKey(SourceTable);
columns = SourceTable.PrimaryKey.MemberColumns;
break;
}
for (int i = 0; i < columns.Count; i++)
{
sb.Append(Indent(indentLevel, true));
sb.Append(GetSqlParameterStatement(columns[i], statementType));
if (IsCommaNecessary(columns, i, ignoreAutoSetColumns))
{
sb.Append(",");
}
}
sb.Append(Indent(--indentLevel, true));
sb.Append(")");
sb.Append(Indent(indentLevel++, true));
sb.Append("AS");
sb.Append(GetSqlStatement(statementType, indentLevel));
sb.Append(Indent(--indentLevel, true));
sb.Append("GO");
return(sb.ToString());
}
/// <summary>
/// 根据类型构造SQL语句
/// </summary>
/// <param name="sqlStatementType">SQL语句类型</param>
/// <param name="dbType">数据库类型</param>
/// <returns>SQL语句</returns>
public static SqlStatement CreateSqlStatement(SqlStatementType sqlStatementType, DbType dbType)
{
switch (sqlStatementType)
{
case SqlStatementType.Select:
switch (dbType)
{
case DbType.SQLServer:
return(new SelectSqlStaForMSS());
case DbType.Oracle:
return(new SelectSqlStaForORA());
default:
return(new SelectSqlStatement());
}
case SqlStatementType.Insert:
{
switch (dbType)
{
case DbType.SQLServer:
return(new InsertSqlStaMSS());
case DbType.Oracle:
return(new InsertSqlStaORA());
default:
return(new InsertSqlStaMSS());
}
}
case SqlStatementType.Delete:
return(new DeleteSqlStatement());
case SqlStatementType.Update:
switch (dbType)
{
case DbType.SQLServer:
return(new UpdateSqlStaForMSS());
case DbType.Oracle:
return(new UpdateSqlStaForORA());
default:
return(new UpdateSqlStatement());
}
default:
return(null);
}
}
public SqlStatementLog(SqlStatementType type, object parameters, string statement, long duration)
{
statementType = type;
this.statement = statement;
this.durationMs = duration;
try
{
statementParameters = JsonUtil.Mapper.writeValueAsString(parameters).replaceAll("\"", "'");
}
catch (Exception)
{
// e.printStackTrace();
}
}
public string GetProcDeclaration(SqlStatementType statementType, int indentLevel)
{
string procName = GetProcName(statementType);
StringBuilder sb = new StringBuilder(GetProcDropStatement(procName, indentLevel));
sb.Append(Indent(indentLevel, true));
sb.Append(GetProcCreateStatement(procName, statementType, indentLevel));
if(ExecuteRoles.Count > 0) {
sb.Append(Indent(indentLevel, true));
foreach(string role in ExecuteRoles) {
sb.Append(GetProcGrantExecuteStatement(procName, role, indentLevel));
}
sb.Append(Indent(indentLevel, true));
sb.Append("GO");
}
return sb.ToString();
}
public string GetProcDeclaration(SqlStatementType statementType, int indentLevel)
{
string procName = GetProcName(statementType);
StringBuilder sb = new StringBuilder(GetProcDropStatement(procName, indentLevel));
sb.Append(Indent(indentLevel, true));
sb.Append(GetProcCreateStatement(procName, statementType, indentLevel));
if (ExecuteRoles.Count > 0)
{
sb.Append(Indent(indentLevel, true));
foreach (string role in ExecuteRoles)
{
sb.Append(GetProcGrantExecuteStatement(procName, role, indentLevel));
}
sb.Append(Indent(indentLevel, true));
sb.Append("GO");
}
return(sb.ToString());
}
public string GetSqlParameterStatement(ColumnSchema column, SqlStatementType statementType)
{
bool isOutput = false;
if (statementType == SqlStatementType.Insert || statementType == SqlStatementType.Update)
{
isOutput = string.Compare(column.Name, TimeStampColumn, true) == 0;
}
if (!isOutput && statementType == SqlStatementType.Insert)
{
isOutput = IsIdentity(column);
}
string parameterStatement = GetSqlParameterStatement(column, isOutput);
if (isOutput)
{
parameterStatement = parameterStatement.Replace("@", "@New");
}
return(parameterStatement);
}
protected string GetSqlStatement(SqlStatementType statementType, int indentLevel)
{
switch (statementType)
{
case SqlStatementType.Select:
return(this.GetSelectStatement(false, indentLevel));
case SqlStatementType.SelectBy:
return(this.GetSelectStatement(true, indentLevel));
case SqlStatementType.Insert:
return(GetInsertStatement(indentLevel));
case SqlStatementType.Update:
return(GetUpdateStatement(indentLevel));
case SqlStatementType.Delete:
return(GetDeleteStatement(indentLevel));
default:
throw new ArgumentOutOfRangeException("statementType", statementType.ToString(), "No statement template has been defined for this SqlStatementType");
}
}
public string GetProcDeclaration(SqlStatementType statementType)
{
return GetProcDeclaration(statementType, 0);
}
private static List <Statement> GetDefaultSqlStatement(String logicDbName, IShardingStrategy shardingStrategy,
String sql, StatementParameterCollection parameters, IDictionary hints, SqlStatementType sqlType, OperationType?operationType = null)
{
if (String.IsNullOrEmpty(logicDbName))
{
throw new DalException("Please specify databaseSet.");
}
if (String.IsNullOrEmpty(sql))
{
throw new DalException("Please specify sql.");
}
var result = new List <Statement>();
var tupleList = ShardingUtil.GetShardInfo(logicDbName, shardingStrategy, parameters, hints);
if (tupleList.Count < 1)
{
//非sharding的场合
Statement statement = GetStatement(logicDbName, StatementType.Sql,
operationType ?? OperationType.Default, sqlType, hints, null);
statement.StatementText = GetSql(sql, null);
statement.Parameters = parameters;
#if !NETSTANDARD
CurrentStackCustomizedLog(statement);
#endif
result.Add(statement);
}
else
{
var bulkCopy = false;
if (hints != null && hints.Contains(DALExtStatementConstant.BULK_COPY))//查看是否是批量插入的case
{
bulkCopy = Convert.ToBoolean(hints[DALExtStatementConstant.BULK_COPY]);
}
if (bulkCopy)
{
result.AddRange(BulkCopyCase(logicDbName, shardingStrategy, sql, parameters, hints, tupleList, sqlType, operationType));
}
else
{
foreach (var tuple in tupleList)
{
Statement statement = GetStatement(logicDbName, StatementType.Sql, operationType ?? OperationType.Default, sqlType, hints, tuple.Item1);
statement.StatementText = GetSql(sql, tuple.Item2);
statement.Parameters = parameters;
#if !NETSTANDARD
CurrentStackCustomizedLog(statement);
#endif
result.Add(statement);
}
}
}
return(result);
}
/// <summary>
/// Create new Stored proc parameter.
/// </summary>
/// <param name="paramName">Sql parameter name.</param>
/// <param name="paramType"><see cref="SqlDbType"/> parameter type.</param>
/// <param name="usedFor">Identifies the purpose of the parameter.</param>
private StoredProcParameter(string paramName, SqlDbType paramType, SqlStatementType[] usedFor)
: this(new SqlParameter(paramName, paramType), usedFor)
{
}
internal void SetStatementType(SqlStatementType statementType)
{
StatementType = statementType;
}
//private static IDictionary<String, IList<T>> ShuffledByDb<T>(String logicDbName, IShardingStrategy shardingStrategy, StatementParameterCollection parameters,
// IList<T> list, IDictionary hints)
//{
// if (String.IsNullOrEmpty(logicDbName))
// return null;
// if (list == null || list.Count == 0)
// return null;
// var dict = new Dictionary<String, IList<T>>();
// foreach (var item in list)
// {
// String shardId = GetShardId(logicDbName, shardingStrategy, parameters, hints);
// if (String.IsNullOrEmpty(shardId))
// continue;
// if (!dict.ContainsKey(shardId))
// dict.Add(shardId, new List<T>());
// dict[shardId].Add(item);
// }
// return dict;
//}
//private static IDictionary<String, IList<T>> ShuffledByTable<T>(String logicDbName, IShardingStrategy shardingStrategy, StatementParameterCollection parameters,
// IList<T> list,IDictionary hints)
//{
// if (String.IsNullOrEmpty(logicDbName))
// return null;
// if (list == null || list.Count == 0)
// return null;
// var dict = new Dictionary<String, IList<T>>();
// foreach (var item in list)
// {
// String tableId = GetTableId(logicDbName, shardingStrategy, parameters, hints);
// if (String.IsNullOrEmpty(tableId))
// continue;
// if (!dict.ContainsKey(tableId))
// dict.Add(tableId, new List<T>());
// dict[tableId].Add(item);
// }
// return dict;
//}
//private static IDictionary<String, IDictionary<String, IList<T>>> ShuffledByDbTable<T>(String logicDbName, IShardingStrategy shardingStrategy, StatementParameterCollection parameters,
// IList<T> list, IDictionary hints)
//{
// if (String.IsNullOrEmpty(logicDbName))
// return null;
// if (list == null || list.Count == 0)
// return null;
// var dict = new Dictionary<String, IDictionary<String, IList<T>>>();
// foreach (var item in list)
// {
// String shardId = GetShardId(logicDbName, shardingStrategy, parameters, hints);
// String tableId = GetTableId(logicDbName, shardingStrategy , parameters,hints);
// if (!dict.ContainsKey(shardId))
// dict.Add(shardId, new Dictionary<String, IList<T>>());
// if (!dict[shardId].ContainsKey(tableId))
// dict[shardId].Add(tableId, new List<T>());
// dict[shardId][tableId].Add(item);
// }
// return dict;
//}
#endregion Shuffled Items
public static IList <Statement> GetShardStatement(String logicDbName, IShardingStrategy shardingStrategy,
StatementParameterCollection parameters, IDictionary hints, Func <IDictionary, List <Statement> > func, SqlStatementType sqlStatementType)
{
IList <Statement> statements;
if (shardingStrategy == null)
{
return(null);
}
var shardingType = GetShardingType(shardingStrategy);
if (shardingType != ShardingType.ShardByDBAndTable)
{
IList <String> shards = null;
//Get shards from hints
if (hints != null)
{
IList <String> temp = null;
if (shardingType == ShardingType.ShardByDB) //是分库的情况
{
if (hints.Contains(DALExtStatementConstant.SHARD_IDS)) //看下hints里面有没有指定分配id(一组)
{
temp = hints[DALExtStatementConstant.SHARD_IDS] as List <String>;
}
else if (hints.Contains(DALExtStatementConstant.SHARDID))//单个的分配id
{
temp = new List <String> {
hints[DALExtStatementConstant.SHARDID] as String
};
}
}
else if (shardingType == ShardingType.ShardByTable)//是分表的情况
{
if (hints.Contains(DALExtStatementConstant.TABLE_IDS))
{
temp = hints[DALExtStatementConstant.TABLE_IDS] as List <String>;
}
else if (hints.Contains(DALExtStatementConstant.TABLEID))
{
temp = new List <String> {
hints[DALExtStatementConstant.TABLEID] as String
};
}
}
if (temp != null)
{
shards = temp;
}
}
var bulkCopy = false;
if (hints != null && hints.Contains(DALExtStatementConstant.BULK_COPY))//查看是否是批量插入的case
{
bulkCopy = Convert.ToBoolean(hints[DALExtStatementConstant.BULK_COPY]);
}
if (bulkCopy)
{
return(func.Invoke(hints));
}
//Get shards from parameters 这里会根据 查询参数得出分配的信息
if (shards == null)
{
if (shardingType == ShardingType.ShardByDB)
{
shards = GetShardId(logicDbName, shardingStrategy, parameters, hints);
}
else if (shardingType == ShardingType.ShardByTable)
{
shards = GetTableId(logicDbName, shardingStrategy, parameters, hints);
}
}
//对于不带条件的查询 都默认查询所有的
if ((shards == null || shards.Count == 0) && sqlStatementType.Equals(SqlStatementType.SELECT))
{
shards = shardingStrategy.AllShards;
}
if (shards == null || shards.Count == 0)
{
throw new DalException("Please provide shard information.");
}
//Build statements
statements = new List <Statement>();
foreach (var item in shards.Distinct())
{
var newHints = HintsUtil.CloneHints(hints);
switch (shardingType)
{
case ShardingType.ShardByDB:
newHints[DALExtStatementConstant.SHARDID] = item;
break;
case ShardingType.ShardByTable:
newHints[DALExtStatementConstant.TABLEID] = item;
break;
}
var statement = func.Invoke(newHints);
foreach (var ss in statement)
{
statements.Add(ss);
}
}
}
else
{
statements = new List <Statement>();
IDictionary <String, IList <String> > shardDict = null;
if (hints != null && hints.Contains(DALExtStatementConstant.SHARD_TABLE_DICT))
{
shardDict = hints[DALExtStatementConstant.SHARD_TABLE_DICT] as IDictionary <String, IList <String> >;
}
if (shardDict == null)
{
var newHints = HintsUtil.CloneHints(hints);
newHints[DALExtStatementConstant.SHARDID] = GetShardIdByHints(hints);
newHints[DALExtStatementConstant.TABLEID] = GetTableIdByHints(hints);
var statement = func.Invoke(newHints);
foreach (var ss in statement)
{
statements.Add(ss);
}
}
else
{
foreach (var shard in shardDict)
{
foreach (var table in shard.Value)
{
var newHints = HintsUtil.CloneHints(hints);
newHints[DALExtStatementConstant.SHARDID] = shard.Key;
newHints[DALExtStatementConstant.TABLEID] = table;
var statement = func.Invoke(newHints);
foreach (var ss in statement)
{
statements.Add(ss);
}
}
}
}
}
return(statements);
}
public CommandExecutingEventArgs(FbCommand sqlCommand, SqlStatementType statementType)
{
SqlCommand = sqlCommand;
StatementType = statementType;
}
public CommandExecutingEventArgs(FbCommand sqlCommand, SqlStatementType statementType)
{
SqlCommand = sqlCommand;
StatementType = statementType;
}
/// <summary>
/// The trigger function for <see cref="CommandExecuted"/> event.
/// </summary>
/// <param name="commandText">The <see cref="FbCommand.CommandText"/> of the executed SQL command.</param>
/// <param name="dataReader">The <see cref="FbDataReader"/> instance with the returned data. If the
/// command executed is not meant to return data (ex: UPDATE, INSERT...) this parameter must be
/// setled to <b>null</b>.</param>
/// <param name="rowsAffected">The rows that were affected by the executed SQL command. If the executed
/// command is not meant to return this kind of information (ex: SELECT) this parameter must
/// be setled to <b>-1</b>.</param>
private void OnCommandExecuted(FbDataReader dataReader, string commandText, SqlStatementType statementType, int rowsAffected)
{
CommandExecuted?.Invoke(this, new CommandExecutedEventArgs(dataReader, commandText, statementType, rowsAffected));
}
/// <summary>
/// Starts the ordered execution of the SQL statements that are in <see cref="SqlStatements"/> collection.
/// </summary>
/// <param name="autoCommit">Specifies if the transaction should be committed after a DDL command execution</param>
public void Execute(bool autoCommit = true)
{
if (this.SqlStatements == null || this.SqlStatements.Count == 0)
{
throw new InvalidOperationException("There are no commands for execution.");
}
foreach (string sqlStatement in this.SqlStatements)
{
if (string.IsNullOrEmpty(sqlStatement))
{
continue;
}
// initializate outputs to default
int rowsAffected = -1;
FbDataReader dataReader = null;
SqlStatementType statementType = FbBatchExecution.GetStatementType(sqlStatement);
if (!(statementType == SqlStatementType.Connect ||
statementType == SqlStatementType.CreateDatabase ||
statementType == SqlStatementType.Disconnect ||
statementType == SqlStatementType.DropDatabase ||
statementType == SqlStatementType.SetAutoDDL ||
statementType == SqlStatementType.SetDatabase ||
statementType == SqlStatementType.SetNames ||
statementType == SqlStatementType.SetSQLDialect))
{
this.ProvideCommand();
this.sqlCommand.CommandText = sqlStatement;
if (this.sqlTransaction == null && !(statementType == SqlStatementType.Commit || statementType == SqlStatementType.Rollback))
{
this.sqlTransaction = this.sqlConnection.BeginTransaction();
}
this.sqlCommand.Transaction = this.sqlTransaction;
}
try
{
switch (statementType)
{
case SqlStatementType.AlterDatabase:
case SqlStatementType.AlterDomain:
case SqlStatementType.AlterException:
case SqlStatementType.AlterIndex:
case SqlStatementType.AlterProcedure:
case SqlStatementType.AlterRole:
case SqlStatementType.AlterTable:
case SqlStatementType.AlterTrigger:
case SqlStatementType.AlterView:
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(autoCommit);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.Commit:
this.OnCommandExecuting(null);
this.CommitTransaction();
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.Connect:
this.OnCommandExecuting(null);
this.ConnectToDatabase(sqlStatement);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.CreateDatabase:
this.OnCommandExecuting(null);
this.CreateDatabase(sqlStatement);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.CommentOn:
case SqlStatementType.CreateCollation:
case SqlStatementType.CreateDomain:
case SqlStatementType.CreateException:
case SqlStatementType.CreateGenerator:
case SqlStatementType.CreateIndex:
case SqlStatementType.CreateProcedure:
case SqlStatementType.CreateRole:
case SqlStatementType.CreateSequence:
case SqlStatementType.CreateShadow:
case SqlStatementType.CreateTable:
case SqlStatementType.CreateTrigger:
case SqlStatementType.CreateView:
case SqlStatementType.DeclareCursor:
case SqlStatementType.DeclareExternalFunction:
case SqlStatementType.DeclareFilter:
case SqlStatementType.DeclareStatement:
case SqlStatementType.DeclareTable:
case SqlStatementType.Delete:
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(autoCommit);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.Describe:
break;
case SqlStatementType.Disconnect:
this.OnCommandExecuting(null);
this.sqlConnection.Close();
FbConnection.ClearPool(this.sqlConnection);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.DropDatabase:
this.OnCommandExecuting(null);
FbConnection.DropDatabase(this.connectionString.ToString());
this.requiresNewConnection = true;
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.DropCollation:
case SqlStatementType.DropDomain:
case SqlStatementType.DropException:
case SqlStatementType.DropExternalFunction:
case SqlStatementType.DropFilter:
case SqlStatementType.DropGenerator:
case SqlStatementType.DropIndex:
case SqlStatementType.DropProcedure:
case SqlStatementType.DropSequence:
case SqlStatementType.DropRole:
case SqlStatementType.DropShadow:
case SqlStatementType.DropTable:
case SqlStatementType.DropTrigger:
case SqlStatementType.DropView:
case SqlStatementType.EventInit:
case SqlStatementType.EventWait:
case SqlStatementType.Execute:
case SqlStatementType.ExecuteImmediate:
case SqlStatementType.ExecuteProcedure:
this.ProvideCommand().CommandText = sqlStatement;
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(autoCommit);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.ExecuteBlock:
this.ProvideCommand().CommandText = sqlStatement;
this.OnCommandExecuting(this.sqlCommand);
dataReader = this.sqlCommand.ExecuteReader();
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, dataReader, -1);
if (!dataReader.IsClosed)
{
dataReader.Close();
}
break;
case SqlStatementType.Fetch:
break;
case SqlStatementType.Grant:
case SqlStatementType.Insert:
case SqlStatementType.InsertCursor:
case SqlStatementType.Open:
case SqlStatementType.Prepare:
case SqlStatementType.Revoke:
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(autoCommit);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.RecreateProcedure:
case SqlStatementType.RecreateTable:
case SqlStatementType.RecreateTrigger:
case SqlStatementType.RecreateView:
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(autoCommit);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.Rollback:
this.OnCommandExecuting(null);
this.RollbackTransaction();
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.Select:
this.ProvideCommand().CommandText = sqlStatement;
this.OnCommandExecuting(this.sqlCommand);
dataReader = this.sqlCommand.ExecuteReader();
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, dataReader, -1);
if (!dataReader.IsClosed)
{
dataReader.Close();
}
break;
case SqlStatementType.SetAutoDDL:
this.OnCommandExecuting(null);
this.SetAutoDdl(sqlStatement, ref autoCommit);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.SetGenerator:
case SqlStatementType.AlterSequence:
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(autoCommit);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.SetNames:
this.OnCommandExecuting(null);
this.SetNames(sqlStatement);
this.requiresNewConnection = true;
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.SetSQLDialect:
this.OnCommandExecuting(null);
this.SetSqlDialect(sqlStatement);
this.requiresNewConnection = true;
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.SetDatabase:
case SqlStatementType.SetStatistics:
case SqlStatementType.SetTransaction:
case SqlStatementType.ShowSQLDialect:
throw new NotImplementedException();
case SqlStatementType.Update:
case SqlStatementType.Whenever:
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(autoCommit);
this.requiresNewConnection = false;
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
}
}
catch (Exception ex)
{
this.RollbackTransaction();
throw new FbException(string.Format("An exception was thrown when executing command: {1}.{0}Batch execution aborted.{0}The returned message was: {2}.",
Environment.NewLine,
sqlStatement,
ex.Message));
}
}
this.CommitTransaction();
this.sqlConnection.Close();
}
/// <summary>
/// 批量插入分片规则： 解析sqlstring 按照分片进行分组 在重新组合 如果没有找到分片的默认第一个分片
/// </summary>
/// <param name="logicDbName"></param>
/// <param name="shardingStrategy"></param>
/// <param name="sql"></param>
/// <param name="parameters"></param>
/// <param name="hints"></param>
/// <param name="tupleList"></param>
/// <param name="sqlType"></param>
/// <param name="operationType"></param>
/// <returns></returns>
private static List <Statement> BulkCopyCase(String logicDbName, IShardingStrategy shardingStrategy,
String sql, StatementParameterCollection parameters, IDictionary hints, List <Tuple <String, String> > tupleList, SqlStatementType sqlType, OperationType?operationType = null)
{
var result = new List <Statement>();
//var shardingDB = tuple.Item1;
//var sharingTable = tuple.Item2;
if (shardingStrategy.ShardByDB && shardingStrategy.ShardByTable)
{
//又分表又分库的情况
}
else if (shardingStrategy.ShardByDB || shardingStrategy.ShardByTable)
{
var dicValues = new Dictionary <string, Tuple <List <string>, StatementParameterCollection> >();
foreach (var tuple in tupleList)
{
dicValues.Add(shardingStrategy.ShardByDB?tuple.Item1: tuple.Item2, Tuple.Create(new List <string>(), new StatementParameterCollection()));
}
var defaultSharding = dicValues.Keys.First();
//分库的情况
var arr = sql.Split(new string[] { "VALUES" }, StringSplitOptions.None);
if (arr.Length != 2)
{
throw new DalException("sharding db for bulkInsert sql string err.");
}
var title = arr[0] + " VALUES ";
var body = arr[1].Replace("\r\n", "");
var values = body.Split(')').Where(r => !string.IsNullOrEmpty(r)).Select(r => r.StartsWith(",")?r.Substring(1):r).ToArray(); //总共有多少行
var first = values.First();
var cloumnCount = first.Split(',').Length; //每行总共有多少列
if (parameters.Count != (cloumnCount * values.Length))
{
throw new DalException("sharding db for bulkInsert sql parameters counts err.");
}
var ii = 0;
//将parameters 按 分库进行分组
for (int i = 0; i < values.Length; i++)
{
var columns = values[i].Split(',');
var haveShardingC = false;
var shardingValue = string.Empty;
List <StatementParameter> newC = new List <StatementParameter>();
for (int j = 0; j < columns.Length; j++)
{
var p = parameters.ElementAt(ii);
if (p.IsShardingColumn)
{
haveShardingC = true;
shardingValue = p.ShardingValue;
}
newC.Add(p);
ii++;
}
if (haveShardingC)
{
if (!string.IsNullOrEmpty(shardingValue))
{
if (dicValues.ContainsKey(shardingValue))
{
dicValues[shardingValue].Item1.Add(values[i] + ")");
foreach (var pp in newC)
{
dicValues[shardingValue].Item2.Add(pp);
}
}
}
else
{
//添加到第一个分片
dicValues[defaultSharding].Item1.Add(values[i] + ")");
foreach (var pp in newC)
{
dicValues[defaultSharding].Item2.Add(pp);
}
}
}
}
foreach (var dic in dicValues)
{
if (dic.Value.Item1.Count == 0)
{
continue;
}
var newHints = HintsUtil.CloneHints(hints);
if (shardingStrategy.ShardByDB)
{
newHints[DALExtStatementConstant.SHARDID] = dic.Key;
}
else
{
newHints[DALExtStatementConstant.TABLEID] = dic.Key;
}
var statement = GetStatement(logicDbName, StatementType.Sql, operationType ?? OperationType.Default, sqlType, newHints, shardingStrategy.ShardByDB? dic.Key:null);
statement.StatementText = shardingStrategy.ShardByDB ? (title + string.Join(",", dic.Value.Item1)): GetSql(title + string.Join(",", dic.Value.Item1), dic.Key);
statement.Parameters = dic.Value.Item2;
#if !NETSTANDARD
CurrentStackCustomizedLog(statement);
#endif
result.Add(statement);
}
}
return(result);
}
/// <summary>
/// Private Create new Stored proc parameter.
/// </summary>
/// <param name="parameter"><see cref="SqlParameter"/>.</param>
/// <param name="usedFor">The array of <see cref="SqlStatementType"/> define where is the parameter used.</param>
private StoredProcParameter(SqlParameter parameter, SqlStatementType[] usedFor)
{
SqlParameter = parameter;
IsForDelete = usedFor.Contains(SqlStatementType.Delete);
IsForInsert = usedFor.Contains(SqlStatementType.Insert);
IsForSelect = usedFor.Contains(SqlStatementType.Select);
IsForUpdate = usedFor.Contains(SqlStatementType.Update);
}
public string GetProcDeclaration(SqlStatementType statementType)
{
return(GetProcDeclaration(statementType, 0));
}
public string GetSqlParameterStatement(ColumnSchema column, SqlStatementType statementType)
{
bool isOutput = false;
if(statementType == SqlStatementType.Insert || statementType == SqlStatementType.Update) {
isOutput = string.Compare(column.Name, TimeStampColumn, true) == 0;
}
if(!isOutput && statementType == SqlStatementType.Insert) {
isOutput = IsIdentity(column);
}
string parameterStatement = GetSqlParameterStatement(column, isOutput);
if(isOutput) {
parameterStatement = parameterStatement.Replace("@", "@New");
}
return parameterStatement;
}
protected string GetProcCreateStatement(string procName, SqlStatementType statementType,
int indentLevel)
{
StringBuilder sb = new StringBuilder();
sb.Append(Indent(indentLevel, true));
sb.Append("CREATE PROCEDURE ");
sb.Append(procName);
sb.Append(Indent(indentLevel++, true));
sb.Append("(");
ColumnSchemaCollection columns;
bool ignoreAutoSetColumns = true;
switch(statementType) {
case SqlStatementType.Insert:
case SqlStatementType.Update:
columns = SourceTable.Columns;
ignoreAutoSetColumns = false;
break;
case SqlStatementType.SelectBy:
CheckForPrimaryKey(ParentTable);
columns = ParentTable.PrimaryKey.MemberColumns;
break;
default:
CheckForPrimaryKey(SourceTable);
columns = SourceTable.PrimaryKey.MemberColumns;
break;
}
for(int i = 0; i < columns.Count; i++) {
sb.Append(Indent(indentLevel, true));
sb.Append(GetSqlParameterStatement(columns[i], statementType));
if(IsCommaNecessary(columns, i, ignoreAutoSetColumns)) {
sb.Append(",");
}
}
sb.Append(Indent(--indentLevel, true));
sb.Append(")");
sb.Append(Indent(indentLevel++, true));
sb.Append("AS");
sb.Append(GetSqlStatement(statementType, indentLevel));
sb.Append(Indent(--indentLevel, true));
sb.Append("GO");
return sb.ToString();
}
/// <summary>
/// The trigger function for <see cref="CommandExecuting"/> event.
/// </summary>
/// <param name="sqlCommand">The SQL command that is going for execution.</param>
private void OnCommandExecuting(FbCommand sqlCommand, SqlStatementType statementType)
{
CommandExecuting?.Invoke(this, new CommandExecutingEventArgs(sqlCommand, statementType));
}
protected string GetSqlStatement(SqlStatementType statementType, int indentLevel)
{
switch(statementType) {
case SqlStatementType.Select:
return this.GetSelectStatement(false, indentLevel);
case SqlStatementType.SelectBy:
return this.GetSelectStatement(true, indentLevel);
case SqlStatementType.Insert:
return GetInsertStatement(indentLevel);
case SqlStatementType.Update:
return GetUpdateStatement(indentLevel);
case SqlStatementType.Delete:
return GetDeleteStatement(indentLevel);
default:
throw new ArgumentOutOfRangeException("statementType", statementType.ToString(), "No statement template has been defined for this SqlStatementType");
}
}
internal void SetStatementType(SqlStatementType statementType)
{
StatementType = statementType;
}
protected string GetProcName(SqlStatementType statementType)
{
switch(statementType) {
case SqlStatementType.Select:
return string.Format(FetchCommandFormat, SourceTable.Name);
case SqlStatementType.SelectBy:
if(ParentTable == null) throw new InvalidOperationException("ParentTable must be specified for SelectBy procs.");
return string.Format(FetchByCommandFormat, SourceTable.Name, ParentTable.Name);
case SqlStatementType.Insert:
return string.Format(InsertCommandFormat, SourceTable.Name);
case SqlStatementType.Update:
return string.Format(UpdateCommandFormat, SourceTable.Name);
case SqlStatementType.Delete:
return string.Format(DeleteCommandFormat, SourceTable.Name);
default:
throw new ArgumentOutOfRangeException("statementType", statementType.ToString(), "No command format has been defined for this SqlStatementType");
}
}
private static Statement GetStatement(String logicDbName, StatementType statementType, OperationType operationType, SqlStatementType sqlType, IDictionary hints, String shardId = null)
{
return(new Statement
{
DatabaseSet = logicDbName,
StatementType = statementType,
OperationType = operationType,
Hints = hints,
ShardID = shardId,
SqlOperationType = sqlType,
});
}
protected string GetTableTimeStampSelect(SqlStatementType statementType, int indentLevel)
{
StringBuilder select = new StringBuilder(Indent(indentLevel, true));
select.Append(SelectStatementTemplate);
select.Replace("[SELECTCOLUMNS]", string.Format("SELECT @New{0} = {0}", TimeStampColumn));
select.Replace("[FROM]", string.Format("FROM {0}", SourceTable.Name));
string parameterName;
StringBuilder where = new StringBuilder("WHERE ");
foreach(ColumnSchema column in SourceTable.PrimaryKey.MemberColumns) {
if(SourceTable.PrimaryKey.MemberColumns.IndexOf(column) > 0) {
where.Append(" AND ");
}
if(statementType == SqlStatementType.Insert && IsIdentity(column)) {
parameterName = string.Format("@New{0}", column.Name);
}
else {
parameterName = string.Format("@{0}", column.Name);
}
where.Append(string.Format("{0} = {1}", column.Name, parameterName));
}
select.Replace("[WHERE]", where.ToString());
return select.ToString();
}
/// <summary>
/// Starts the ordered execution of the SQL statements that are in <see cref="SqlStatements"/> collection.
/// </summary>
/// <param name="autoCommit">Specifies if the transaction should be committed after a DDL command execution</param>
public void Execute(bool autoCommit)
{
if (this.SqlStatements == null || this.SqlStatements.Count == 0)
{
throw new InvalidOperationException("There are no commands for execution.");
}
foreach (string sqlStatement in this.SqlStatements)
{
if (string.IsNullOrEmpty(sqlStatement))
{
continue;
}
// initializate outputs to default
int rowsAffected = -1;
FbDataReader dataReader = null;
SqlStatementType statementType = FbBatchExecution.GetStatementType(sqlStatement);
if (!(statementType == SqlStatementType.Connect ||
statementType == SqlStatementType.CreateDatabase ||
statementType == SqlStatementType.Disconnect ||
statementType == SqlStatementType.DropDatabase ||
statementType == SqlStatementType.SetDatabase ||
statementType == SqlStatementType.SetNames ||
statementType == SqlStatementType.SetSQLDialect))
{
// Update command configuration
this.ProvideCommand();
this.sqlCommand.CommandText = sqlStatement;
// Check how transactions are going to be handled
if (statementType == SqlStatementType.Insert ||
statementType == SqlStatementType.Update ||
statementType == SqlStatementType.Delete)
{
// DML commands should be inside a transaction
if (this.sqlTransaction == null)
{
this.sqlTransaction = this.sqlConnection.BeginTransaction();
}
this.sqlCommand.Transaction = this.sqlTransaction;
}
else if (this.sqlTransaction != null && !(statementType == SqlStatementType.Commit || statementType == SqlStatementType.Rollback))
{
// Non DML Statements should be executed using
// implicit transaction support
this.sqlTransaction.Commit();
this.sqlTransaction = null;
}
}
try
{
switch (statementType)
{
case SqlStatementType.AlterDatabase:
case SqlStatementType.AlterDomain:
case SqlStatementType.AlterException:
case SqlStatementType.AlterIndex:
case SqlStatementType.AlterProcedure:
case SqlStatementType.AlterTable:
case SqlStatementType.AlterTrigger:
case SqlStatementType.AlterView:
// raise the event
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(this.sqlCommand, autoCommit);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.Commit:
// raise the event
this.OnCommandExecuting(null);
this.sqlTransaction.Commit();
this.sqlTransaction = null;
// raise the event
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.Connect:
// raise the event
this.OnCommandExecuting(null);
this.ConnectToDatabase(sqlStatement);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.CreateDatabase:
// raise the event
this.OnCommandExecuting(null);
this.CreateDatabase(sqlStatement);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.CommentOn:
case SqlStatementType.CreateDomain:
case SqlStatementType.CreateException:
case SqlStatementType.CreateGenerator:
case SqlStatementType.CreateIndex:
case SqlStatementType.CreateProcedure:
case SqlStatementType.CreateRole:
case SqlStatementType.CreateSequence:
case SqlStatementType.CreateShadow:
case SqlStatementType.CreateTable:
case SqlStatementType.CreateTrigger:
case SqlStatementType.CreateView:
case SqlStatementType.DeclareCursor:
case SqlStatementType.DeclareExternalFunction:
case SqlStatementType.DeclareFilter:
case SqlStatementType.DeclareStatement:
case SqlStatementType.DeclareTable:
case SqlStatementType.Delete:
// raise the event
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(this.sqlCommand, autoCommit);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.Describe:
break;
case SqlStatementType.Disconnect:
// raise the event
this.OnCommandExecuting(null);
this.sqlConnection.Close();
FbConnection.ClearPool(this.sqlConnection);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.DropDatabase:
// raise the event
this.OnCommandExecuting(null);
FbConnection.DropDatabase(this.connectionString.ToString());
//this.sqlConnection = null;
this.requiresNewConnection = true;
// raise the event
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.DropDomain:
case SqlStatementType.DropException:
case SqlStatementType.DropExternalFunction:
case SqlStatementType.DropFilter:
case SqlStatementType.DropGenerator:
case SqlStatementType.DropIndex:
case SqlStatementType.DropProcedure:
case SqlStatementType.DropSequence:
case SqlStatementType.DropRole:
case SqlStatementType.DropShadow:
case SqlStatementType.DropTable:
case SqlStatementType.DropTrigger:
case SqlStatementType.DropView:
case SqlStatementType.EventInit:
case SqlStatementType.EventWait:
case SqlStatementType.Execute:
case SqlStatementType.ExecuteImmediate:
case SqlStatementType.ExecuteProcedure:
this.ProvideCommand().CommandText = sqlStatement;
// raise the event
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(this.sqlCommand, autoCommit);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.Fetch:
break;
case SqlStatementType.Grant:
case SqlStatementType.Insert:
case SqlStatementType.InsertCursor:
case SqlStatementType.Open:
case SqlStatementType.Prepare:
case SqlStatementType.Revoke:
// raise the event
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(this.sqlCommand, autoCommit);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.RecreateProcedure:
case SqlStatementType.RecreateTable:
case SqlStatementType.RecreateTrigger:
case SqlStatementType.RecreateView:
// raise the event
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(this.sqlCommand, autoCommit);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.Rollback:
// raise the event
this.OnCommandExecuting(null);
this.sqlTransaction.Rollback();
this.sqlTransaction = null;
// raise the event
this.OnCommandExecuted(sqlStatement, null, -1);
break;
case SqlStatementType.Select:
this.ProvideCommand().CommandText = sqlStatement;
// raise the event
this.OnCommandExecuting(this.sqlCommand);
dataReader = this.sqlCommand.ExecuteReader();
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, dataReader, -1);
if (!dataReader.IsClosed)
{
dataReader.Close();
}
break;
case SqlStatementType.SetGenerator:
case SqlStatementType.AlterSequence:
// raise the event
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(this.sqlCommand, autoCommit);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
case SqlStatementType.SetDatabase:
case SqlStatementType.SetNames:
case SqlStatementType.SetSQLDialect:
case SqlStatementType.SetStatistics:
case SqlStatementType.SetTransaction:
case SqlStatementType.ShowSQLDialect:
throw new NotImplementedException();
case SqlStatementType.Update:
case SqlStatementType.Whenever:
// raise the event
this.OnCommandExecuting(this.sqlCommand);
rowsAffected = this.ExecuteCommand(this.sqlCommand, autoCommit);
this.requiresNewConnection = false;
// raise the event
this.OnCommandExecuted(sqlStatement, null, rowsAffected);
break;
}
}
catch (Exception ex)
{
if (this.sqlTransaction != null)
{
this.sqlTransaction.Rollback();
this.sqlTransaction = null;
}
throw new FbException(string.Format(CultureInfo.CurrentUICulture, "An exception was thrown when executing command: {0}{2}Batch execution aborted{2}The returned message was: {1}", sqlStatement, ex.Message, Environment.NewLine));
}
}
if (this.sqlTransaction != null)
{
// commit root transaction
this.sqlTransaction.Commit();
this.sqlTransaction = null;
}
this.sqlConnection.Close();
}
private static Statement GetDefaultSqlStatement(String logicDbName,
String sql, StatementParameterCollection parameters, IDictionary hints, SqlStatementType sqlType, OperationType?operationType = null)
{
if (String.IsNullOrEmpty(logicDbName))
{
throw new DalException("Please specify databaseSet.");
}
if (String.IsNullOrEmpty(sql))
{
throw new DalException("Please specify sql.");
}
Statement statement = GetStatement(logicDbName, StatementType.Sql, operationType ?? OperationType.Default, sqlType, hints);
statement.StatementText = sql;
statement.Parameters = parameters;
CurrentStackCustomizedLog(statement);
return(statement);
}
