/// <summary>
/// Takes a GIS model and a file and writes the model to that file.
/// </summary>
/// <param name="model">
/// The GisModel which is to be persisted.
/// </param>
/// <param name="fileName">
/// The name of the file in which the model is to be persisted.
/// </param>
public void Persist(GisModel model, string fileName)
{
Initialize(model);
PatternedPredicate[] predicates = GetPredicates();
if ( File.Exists(fileName))
{
File.Delete(fileName);
}
using (mDataConnection = new SQLiteConnection("Data Source=" + fileName + ";New=True;Compress=False;Synchronous=Off;UTF8Encoding=True;Version=3"))
{
mDataConnection.Open();
mDataCommand = mDataConnection.CreateCommand();
CreateDataStructures();
using (mDataTransaction = mDataConnection.BeginTransaction())
{
mDataCommand.Transaction = mDataTransaction;
CreateModel(model.CorrectionConstant, model.CorrectionParameter);
InsertOutcomes(model.GetOutcomeNames());
InsertPredicates(predicates);
InsertPredicateParameters(model.GetOutcomePatterns(), predicates);
mDataTransaction.Commit();
}
mDataConnection.Close();
}
}
public void open()
{
SetConnection();
sql_con.Open();
_sqLiteTransaction = sql_con.BeginTransaction();
sql_cmd = sql_con.CreateCommand();
}
public SQLiteTransaction(SQLiteDatabase database, IsolationLevel level, SQLiteSettings settings)
{
_database = database;
_settings = settings;
_connection = _database.ConnectionPool.GetConnection();
_transaction = _connection.BeginTransaction(level);
}
/// <summary>
/// Run the list command for input connection
/// </summary>
/// <param name="connection"></param>
/// <param name="list"></param>
void RunSqlCommand(System.Data.SQLite.SQLiteConnection connection, List <string> list)
{
int i = 0;
using (System.Data.SQLite.SQLiteTransaction trans = connection.BeginTransaction())
{
System.Data.SQLite.SQLiteCommand command = new System.Data.SQLite.SQLiteCommand(connection);
foreach (string commandText in list)
{
try
{
if (commandText.Trim().Length == 0)
{
continue;
}
command.CommandText = commandText;
command.ExecuteNonQuery();
i++;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
trans.Commit();
}
list.Clear();
}
public SQLiteTransaction(SQLiteDatabase database, IsolationLevel level, SQLiteSettings settings)
{
_database = database;
_settings = settings;
_connection = _database.ConnectionPool.GetConnection();
_transaction = _connection.BeginTransaction(level);
}
public SQLiteCommand(string commandText, SQLiteConnection connection, SQLiteTransaction transaction)
{
CommandText = commandText;
DbConnection = connection;
DbTransaction = transaction;
m_parameterCollection = new SQLiteParameterCollection();
}
public AbstractDatabase(string db_path)
{
conn_ = new SQLiteConnection("Data Source=" + db_path);
tables_ = new Dictionary <string, AbstractTable>();
transaction_ = null;
DBFilePath = db_path;
}
///////////////////////////////////////////////////////////////////////////////////////////////
private /* protected virtual */ void Dispose(bool disposing)
{
if (!disposed)
{
if (disposing)
{
////////////////////////////////////
// dispose managed resources here...
////////////////////////////////////
if (_transaction != null)
{
_transaction.Dispose();
_transaction = null;
}
if (_scope != null)
{
// _scope.Dispose(); // NOTE: Not "owned" by us.
_scope = null;
}
}
//////////////////////////////////////
// release unmanaged resources here...
//////////////////////////////////////
disposed = true;
}
}
public void CommitTransaction()
{
globalTransaction.Commit();
globalTransaction.Dispose();
globalTransaction = null;
Close();
}
internal SQLiteEnlistment(SQLiteConnection cnn, Transaction scope)
{
_transaction = cnn.BeginTransaction();
_scope = scope;
_scope.EnlistVolatile(this, System.Transactions.EnlistmentOptions.None);
}
public SQLiteCommand GetCommandOnCurrentConnect(String commandText, out SQLiteTransaction sqLiteTransaction){
var connection = GetCurrentConnection();
sqLiteTransaction = connection.BeginTransaction();
return new SQLiteCommand(commandText, connection, sqLiteTransaction);
}
internal static void PrepareCommand(SQLiteCommand command, SQLiteConnection connection, SQLiteTransaction transaction,
CommandType commandType, string commandText, SQLiteParameter[] commandParameters,
out bool mustCloseConnection)
{
if (command == null) throw new ArgumentNullException("command");
if (string.IsNullOrEmpty(commandText)) throw new ArgumentNullException("commandText");
if (connection.State == ConnectionState.Open)
mustCloseConnection = false;
else
{
mustCloseConnection = true;
connection.Open();
}
command.Connection = connection;
command.CommandText = commandText;
if (transaction != null)
{
if (transaction.Connection == null)
throw new ArgumentException(
"The transaction was rollbacked or commited, please provide an open transaction.", "transaction");
command.Transaction = transaction;
}
command.CommandType = commandType;
if (commandParameters != null)
AttachParameters(command, commandParameters);
return;
}
public SQLiteCommand CreateAddProductCommand(SQLiteConnection conn, SQLiteTransaction transaction)
{
var cmd = new SQLiteCommand(_sql, conn, transaction);
CreateParameters(cmd);
return cmd;
}
protected long ExecuteNonQuery(
string sql,
IEnumerable<SQLiteParameter> parameters,
SQLiteTransaction transaction = null
)
{
long iRows = 0L;
this.Logger.DebugFormat("Datasource:'{0}';sql:'{1}'",
this.Connection.DataSource,
sql
);
using (SQLiteCommand command = this.GetCommand(sql, transaction))
{
if (parameters != null)
{
foreach (SQLiteParameter parameter in parameters)
{
command.Parameters.Add(parameter);
}
}
iRows = command.ExecuteNonQuery();
}
// this.Logger.DebugFormat("ExecuteNonQuery:ExecuteNonQuery:sql:'{0}';rows:'{1}'",
// sql,
// iRows
// );
return iRows;
}
public Transaction(SQLiteTransaction transaction)
{
if (_base == null)
throw new ArgumentNullException("transaction");
_base = transaction;
}
/// <summary>
/// 更新数据库
/// </summary>
/// <param name="sql">数据库语句</param>
public static void SQLUpdate(string sql)
{
using (SQLiteConnection conn = new SQLiteConnection(ConnectionString))
{
conn.Open(); // 连接数据库
using (System.Data.SQLite.SQLiteTransaction trans = conn.BeginTransaction())
{
using (SQLiteCommand cmd = new SQLiteCommand(conn))
{
//事务处理
cmd.Transaction = trans;
try
{
cmd.CommandText = sql;
cmd.ExecuteNonQuery();
trans.Commit();
}
catch (Exception)
{
trans.Rollback();
}
}
}
}
}
public void CommitTran()
{
if (_tran != null)
{
_tran.Commit();
_tran = null;
}
}
private SQLiteCommand GetCommand(string sql, SQLiteTransaction transaction)
{
return new SQLiteCommand(
sql,
this.Connection,
transaction
);
}
public void Begin(IsolationLevel level)
{
if (_transaction != null)
{
_transaction.Rollback();
}
_transaction = _connection.BeginTransaction(IsolationLevel.Serializable);
}
private void init(string connString) {
connection = new SQLiteConnection(connString);
connection.Open();
//connection.ChangeDatabase(Server.MySQLDatabaseName);
transaction = connection.BeginTransaction();
}
private void Cleanup(SQLiteConnection cnn)
{
if (_disposeConnection)
cnn.Dispose();
_transaction = null;
_scope = null;
}
public void SetCommandConstraints(
string clause,
IEnumerable<SQLiteParameter> parameters,
SQLiteTransaction transaction = null
)
{
this._clause = clause;
this._parameters = parameters;
this._transaction = transaction;
}
/// <summary>
/// Default Constructor for SQLiteDatabase Class.
/// </summary>
/// <param name="transaction">Allow programmers to insert, update and delete values in one transaction</param>
public SQLiteDatabase(bool transaction = false)
{
_transaction = transaction;
DBConnection = "Data Source=" + System.Web.Hosting.HostingEnvironment.MapPath("~/App_Data/eCrit.db") + ";Verson=3;";
if (transaction)
{
_sqLiteConnection = new SQLiteConnection(DBConnection);
_sqLiteConnection.Open();
_sqLiteTransaction = _sqLiteConnection.BeginTransaction();
}
}
//开始一个事务处理
public void beginTrans()
{
try
{
tran = conn.BeginTransaction();
}
catch (System.Exception ex)
{
}
}
//initiates the the beginning of the transaction (any subsequent database operations
// will be rolled back if any error occurs before the changes are committed)
public static void beginTransaction()
{
lock (threadLock) {
try {
transaction = connection.BeginTransaction();
}
catch (SQLiteException error) {
Util.logError(error.Message);
}
}
}
public override void Rollback()
{
if (IsDisposed)
throw new ObjectDisposedException(this.GetType().ToString());
SQLiteConnection cnn = _transaction.Connection;
_transaction.Rollback();
if (cnn != null && cnn.State != System.Data.ConnectionState.Closed)
cnn.Close();
_transaction = null;
cnn = null;
}
public SQLiteTransaction(SQLiteDatabase database, IsolationLevel level, SQLiteSettings settings)
{
_database = database;
_settings = settings;
#if NO_POOL
_connection = _database.CreateOpenAndInitializeConnection();
#else
_connection = _database.ConnectionPool.GetConnection();
#endif
_transaction = _connection.BeginTransaction(level);
}
public SQLiteMonTransaction(SQLiteTransaction transaction)
{
this.wrappedTrans = transaction;
StackTrace trace = new StackTrace(true);
lock (readerInfoLock)
{
readerInfo.Add(this.wrappedTrans, trace.ToString());
}
}
public DbTransaction()
{
if (CurrentTransaction != null)
throw new ApplicationException("There is another transaction active on this thread!");
SQLiteConnection conn = new SQLiteConnection(ConfigurationManager.ConnectionStrings[ConnectionStringName].ConnectionString);
conn.Open();
_transaction = conn.BeginTransaction();
CurrentTransaction = this;
}
public void beginTransaction()
{
try
{
transaction = connection.BeginTransaction();
command.Transaction = transaction;
}
catch (Exception myExp)
{
throw myExp;
}
}
public void ExecuteNonQuery(string query, SQLiteTransaction trans, params Tuple<string,string>[] parameters)
{
using (SQLiteCommand cmd = new SQLiteCommand(query, connection,trans))
{
foreach (var p in parameters)
{
cmd.Parameters.Add(p.Item1, DbType.String).Value = p.Item2;
}
cmd.ExecuteNonQuery();
}
}
public ReplaceCommand(
SQLiteConnection connection,
TableDefinition tableDefinition,
SQLiteTransaction transaction = null
) : base(
connection,
tableDefinition
)
{
this._rows = new List<ITableRow>();
this._transaction = transaction;
}
/// <summary>
/// Initializes a new instance of the <see cref="SetJobLastKnownEventCommand" /> class.
/// </summary>
/// <param name="jobName">Name of the job.</param>
/// <param name="jobEventTime">The time.</param>
/// <param name="jobScheduledTime">The job scheduled time.</param>
/// <param name="connection">The connection.</param>
/// <param name="transaction">The transaction.</param>
public SetJobLastKnownEventCommand(string jobName,
DateTimeOffset jobEventTime,
DateTimeOffset jobScheduledTime,
SQLiteConnection connection,
SQLiteTransaction transaction)
{
JobName = jobName;
JobEventTime = jobEventTime;
JobScheduledTime = jobScheduledTime;
Connection = connection;
Transaction = transaction;
}
public void InsereExtensao(ExtensaoModel _extensao, SQLiteTransaction _dbTransaction = null)
{
string strSQL = string.Format("INSERT INTO EXTENSAO (EXTENSAO) VALUES ('{0}')",
_extensao);
m_dbHelper.Connection.Open();
using (SQLiteCommand cmd = new SQLiteCommand(strSQL, m_dbHelper.Connection))
{
cmd.ExecuteNonQuery();
}
m_dbHelper.Connection.Close();
}
public RowDeleteCommand(
SQLiteConnection connection,
TableDefinition tableDefinition
) : base(
connection,
tableDefinition
)
{
this._clause = null;
this._parameters = null;
this._transaction = null;
}
protected override void OnDispose()
{
if (_transaction != null)
{
SQLiteConnection cnn = _transaction.Connection;
_transaction.Rollback();
if (cnn != null && cnn.State != System.Data.ConnectionState.Closed)
cnn.Close();
_transaction = null;
cnn = null;
}
}
/// <summary>
/// Commence une transaction sql isolée
/// ATTENTION LES OUVERTURES ET FERMETURES DE LA BASE NE SERONT PLUS AUTOMATIQUES
/// </summary>
public override bool BeginTransaction(string transactionName = null)
{
if (conn == null)
{
this.Open();
}
if (this.transac != null)
{
return(false); // postgres authorise qu'une transaction
}
transac = conn.BeginTransaction();
return(true);
}
public override bool CommitTransaction(string transactionName = null)
{
if (conn == null)
{
return(false);
}
if (transac == null)
{
return(false);
}
transac.Commit();
transac.Dispose();
transac = null;
return(true);
}
public override bool RollBackTransaction(string transactionName = null)
{
if (conn == null)
{
return(false);
}
if (transac == null)
{
return(false);
}
transac.Rollback();
transac.Dispose();
transac = null;
return(true);
}
public void Dispose()
{
// Dispose the System.Data.SQLite.SQLiteTransaction. If neither Commit nor Rollback was
// called before, the standard behaviour of System.Data.SQLite.SQLiteTransaction is to
// issue a Rollback during disposing.
if (_transaction != null)
{
_transaction.Dispose();
_transaction = null;
}
// Return the underlying connection to the connection pool without closing it
if (_connection != null)
{
_database.ConnectionPool.PutConnection(_connection);
_connection = null;
}
}
public void CommitTransaction()
{
transaction_.Commit();
transaction_ = null;
}
/// <summary>
/// Execute Entities
/// </summary>
/// <param name="conn"></param>
/// <param name="cmdText"></param>
/// <param name="commandType"></param>
/// <param name="transaction"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static IEnumerable <T> ExecuteEntities <T>(this SQLiteConnection conn, string cmdText, CommandType commandType, SQLiteTransaction transaction) where T : new()
{
conn.CheckNull(nameof(conn));
return(conn.ExecuteEntities <T>(cmdText, null, commandType, transaction));
}
/// <summary>
/// Execute scalar as
/// </summary>
/// <param name="conn"></param>
/// <param name="cmdText"></param>
/// <param name="parameters"></param>
/// <param name="commandType"></param>
/// <param name="transaction"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static T ExecuteScalarAs <T>(this SQLiteConnection conn, string cmdText, SQLiteParameter[] parameters, CommandType commandType, SQLiteTransaction transaction)
{
conn.CheckNull(nameof(conn));
using var command = conn.CreateCommand(cmdText, commandType, transaction, parameters);
return((T)command.ExecuteScalar());
}
/// <summary>
/// Adds the specified user names to the specified roles for the configured applicationName.
/// </summary>
/// <param name="usernames">A string array of user names to be added to the specified roles.</param>
/// <param name="roleNames">A string array of the role names to add the specified user names to.</param>
public override void AddUsersToRoles(string[] usernames, string[] roleNames)
{
foreach (string roleName in roleNames)
{
if (!RoleExists(roleName))
{
throw new ProviderException("Role name not found.");
}
}
foreach (string username in usernames)
{
if (username.IndexOf(',') > 0)
{
throw new ArgumentException("User names cannot contain commas.");
}
foreach (string RoleName in roleNames)
{
if (IsUserInRole(username, RoleName))
{
throw new ProviderException("User is already in role.");
}
}
}
SQLiteTransaction tran = null;
SQLiteConnection cn = GetDBConnectionForRole();
try
{
if (cn.State == ConnectionState.Closed)
{
cn.Open();
}
if (!IsTransactionInProgress())
{
tran = cn.BeginTransaction();
}
using (SQLiteCommand cmd = cn.CreateCommand())
{
cmd.CommandText = "INSERT INTO " + USERS_IN_ROLES_TB_NAME
+ " (UserId, RoleId)"
+ " SELECT u.UserId, r.RoleId"
+ " FROM " + USER_TB_NAME + " u, " + ROLE_TB_NAME + " r"
+ " WHERE (u.LoweredUsername = $Username) AND (u.ApplicationId = $ApplicationId)"
+ " AND (r.LoweredRoleName = $RoleName) AND (r.ApplicationId = $ApplicationId)";
SQLiteParameter userParm = cmd.Parameters.Add("$Username", DbType.String, MAX_USERNAME_LENGTH);
SQLiteParameter roleParm = cmd.Parameters.Add("$RoleName", DbType.String, MAX_ROLENAME_LENGTH);
cmd.Parameters.AddWithValue("$ApplicationId", _applicationId);
foreach (string username in usernames)
{
foreach (string roleName in roleNames)
{
userParm.Value = username.ToLowerInvariant();
roleParm.Value = roleName.ToLowerInvariant();
cmd.ExecuteNonQuery();
}
}
// Commit the transaction if it's the one we created in this method.
if (tran != null)
{
tran.Commit();
}
}
}
catch
{
if (tran != null)
{
tran.Rollback();
}
throw;
}
finally
{
if (tran != null)
{
tran.Dispose();
}
if (!IsTransactionInProgress())
{
cn.Dispose();
}
}
}
/// <summary>
/// Executes the command.
/// </summary>
/// <param name="dbCommand">The current sql command.</param>
/// <param name="commandText">The command text to execute.</param>
/// <param name="commandType">The command type.</param>
/// <param name="connectionString">The connection string to use.</param>
/// <param name="values">The collection of sql parameters to include.</param>
/// <returns>-1 if command execution failed.</returns>
public Int32 ExecuteCommand(ref DbCommand dbCommand, string commandText,
CommandType commandType, string connectionString, params DbParameter[] values)
{
// Initial connection objects.
dbCommand = null;
Int32 returnValue = -1;
SqliteClient.SQLiteConnection sqlConnection = null;
SqliteClient.SQLiteTransaction sqlTransaction = null;
try
{
// Create a new connection.
using (sqlConnection = new SqliteClient.SQLiteConnection(connectionString))
{
// Open the connection.
sqlConnection.Open();
// Start a new transaction.
sqlTransaction = sqlConnection.BeginTransaction();
// Create the command and assign any parameters.
dbCommand = new SqliteClient.SQLiteCommand(DataTypeConversion.GetSqlConversionDataTypeNoContainer(
ConnectionContext.ConnectionDataType.SqlDataType, commandText), sqlConnection);
dbCommand.CommandType = commandType;
dbCommand.Transaction = sqlTransaction;
if (values != null)
{
foreach (SqliteClient.SQLiteParameter sqlParameter in values)
{
dbCommand.Parameters.Add(sqlParameter);
}
}
// Execute the command.
returnValue = dbCommand.ExecuteNonQuery();
// Commit the transaction.
sqlTransaction.Commit();
// Close the database connection.
sqlConnection.Close();
}
// Return true.
return(returnValue);
}
catch (Exception ex)
{
try
{
// Attempt to roll back the transaction.
if (sqlTransaction != null)
{
sqlTransaction.Rollback();
}
}
catch { }
// Throw a general exception.
throw new Exception(ex.Message, ex.InnerException);
}
finally
{
if (sqlConnection != null)
{
sqlConnection.Close();
}
}
}
/// <summary>
/// Execute ExpandoObjects
/// </summary>
/// <param name="conn"></param>
/// <param name="cmdText"></param>
/// <param name="commandType"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static IEnumerable <dynamic> ExecuteExpandoObjects(this SQLiteConnection conn, string cmdText, CommandType commandType, SQLiteTransaction transaction)
{
conn.CheckNull(nameof(conn));
return(conn.ExecuteExpandoObjects(cmdText, null, commandType, transaction));
}
internal SQLiteEnlistment(SQLiteConnection cnn)
{
_transaction = cnn.BeginTransaction();
_transaction.Connection._enlisted = true;
}
public void BeginTransaction()
{
transaction_ = conn_.BeginTransaction();
}
/// <summary>
/// Removes the specified user names from the specified roles for the configured applicationName.
/// </summary>
/// <param name="usernames">A string array of user names to be removed from the specified roles.</param>
/// <param name="roleNames">A string array of role names to remove the specified user names from.</param>
public override void RemoveUsersFromRoles(string[] usernames, string[] roleNames)
{
foreach (string roleName in roleNames)
{
if (!RoleExists(roleName))
{
throw new ProviderException("Role name not found.");
}
}
foreach (string username in usernames)
{
foreach (string roleName in roleNames)
{
if (!IsUserInRole(username, roleName))
{
throw new ProviderException("User is not in role.");
}
}
}
SQLiteTransaction tran = null;
SQLiteConnection cn = GetDBConnectionForRole();
try
{
if (cn.State == ConnectionState.Closed)
{
cn.Open();
}
if (!IsTransactionInProgress())
{
tran = cn.BeginTransaction();
}
using (SQLiteCommand cmd = cn.CreateCommand())
{
cmd.CommandText = "DELETE FROM " + USERS_IN_ROLES_TB_NAME
+ " WHERE UserId = (SELECT UserId FROM " + USER_TB_NAME + " WHERE LoweredUsername = $Username AND ApplicationId = $ApplicationId)"
+ " AND RoleId = (SELECT RoleId FROM " + ROLE_TB_NAME + " WHERE LoweredRoleName = $RoleName AND ApplicationId = $ApplicationId)";
SQLiteParameter userParm = cmd.Parameters.Add("$Username", DbType.String, MAX_USERNAME_LENGTH);
SQLiteParameter roleParm = cmd.Parameters.Add("$RoleName", DbType.String, MAX_ROLENAME_LENGTH);
cmd.Parameters.AddWithValue("$ApplicationId", _applicationId);
foreach (string username in usernames)
{
foreach (string roleName in roleNames)
{
userParm.Value = username.ToLowerInvariant();
roleParm.Value = roleName.ToLowerInvariant();
cmd.ExecuteNonQuery();
}
}
// Commit the transaction if it's the one we created in this method.
if (tran != null)
{
tran.Commit();
}
}
}
catch
{
if (tran != null)
{
tran.Rollback();
}
throw;
}
finally
{
if (tran != null)
{
tran.Dispose();
}
if (!IsTransactionInProgress())
{
cn.Dispose();
}
}
}
/// <summary>
/// Execute scalar as
/// </summary>
/// <param name="conn"></param>
/// <param name="cmdText"></param>
/// <param name="parameters"></param>
/// <param name="transaction"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static Task <T> ExecuteScalarAsAsync <T>(this SQLiteConnection conn, string cmdText, SQLiteParameter[] parameters, SQLiteTransaction transaction)
{
conn.CheckNull(nameof(conn));
return(conn.ExecuteScalarAsAsync <T>(cmdText, parameters, CommandType.Text, transaction));
}
ExecuteExpandoObjectsAsync(this SQLiteConnection conn, string cmdText, SQLiteParameter[] parameters, SQLiteTransaction transaction)
{
conn.CheckNull(nameof(conn));
return(conn.ExecuteExpandoObjectsAsync(cmdText, parameters, CommandType.Text, transaction));
}
/// <summary>
/// Execute DataSet
/// </summary>
/// <param name="conn"></param>
/// <param name="cmdText"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static DataSet ExecuteDataSet(this SQLiteConnection conn, string cmdText, SQLiteTransaction transaction)
{
conn.CheckNull(nameof(conn));
return(conn.ExecuteDataSet(cmdText, null, CommandType.Text, transaction));
}
private SQLiteCommand(string sqlText, SQLiteConnection dbConn, SQLiteTransaction trans)
{
sql = sqlText;
parent_conn = dbConn;
transaction = trans;
}
public void RollbackTransaction()
{
transaction_.Rollback();
transaction_ = null;
}
/// <summary>
/// Removes a role from the data source for the configured applicationName.
/// </summary>
/// <param name="roleName">The name of the role to delete.</param>
/// <param name="throwOnPopulatedRole">If true, throw an exception if <paramref name="roleName"/> has one or more members and do not delete <paramref name="roleName"/>.</param>
/// <returns>
/// true if the role was successfully deleted; otherwise, false.
/// </returns>
public override bool DeleteRole(string roleName, bool throwOnPopulatedRole)
{
if (!RoleExists(roleName))
{
throw new ProviderException("Role does not exist.");
}
if (throwOnPopulatedRole && GetUsersInRole(roleName).Length > 0)
{
throw new ProviderException("Cannot delete a populated role.");
}
SQLiteTransaction tran = null;
SQLiteConnection cn = GetDBConnectionForRole();
try
{
if (cn.State == ConnectionState.Closed)
{
cn.Open();
}
if (!IsTransactionInProgress())
{
tran = cn.BeginTransaction();
}
using (SQLiteCommand cmd = cn.CreateCommand())
{
cmd.CommandText = "DELETE FROM " + USERS_IN_ROLES_TB_NAME + " WHERE (RoleId IN"
+ " (SELECT RoleId FROM " + ROLE_TB_NAME + " WHERE LoweredRoleName = $RoleName))";
cmd.Parameters.AddWithValue("$RoleName", roleName.ToLowerInvariant());
cmd.ExecuteNonQuery();
}
using (SQLiteCommand cmd = cn.CreateCommand())
{
cmd.CommandText = "DELETE FROM " + ROLE_TB_NAME + " WHERE LoweredRoleName = $RoleName AND ApplicationId = $ApplicationId";
cmd.Parameters.AddWithValue("$RoleName", roleName.ToLowerInvariant());
cmd.Parameters.AddWithValue("$ApplicationId", _applicationId);
cmd.ExecuteNonQuery();
}
// Commit the transaction if it's the one we created in this method.
if (tran != null)
{
tran.Commit();
}
}
catch
{
if (tran != null)
{
tran.Rollback();
}
throw;
}
finally
{
if (tran != null)
{
tran.Dispose();
}
if (!IsTransactionInProgress())
{
cn.Dispose();
}
}
return(true);
}
/// <summary>
/// Execute scalar as
/// </summary>
/// <param name="conn"></param>
/// <param name="cmdText"></param>
/// <param name="commandType"></param>
/// <param name="transaction"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static T ExecuteScalarAs <T>(this SQLiteConnection conn, string cmdText, CommandType commandType, SQLiteTransaction transaction)
{
conn.CheckNull(nameof(conn));
return(conn.ExecuteScalarAs <T>(cmdText, null, commandType, transaction));
}
/// <summary>
/// Execute Entities
/// </summary>
/// <param name="conn"></param>
/// <param name="cmdText"></param>
/// <param name="parameters"></param>
/// <param name="transaction"></param>
/// <typeparam name="T"></typeparam>
/// <returns></returns>
public static Task <IEnumerable <T> > ExecuteEntitiesAsync <T>(this SQLiteConnection conn, string cmdText, SQLiteParameter[] parameters, SQLiteTransaction transaction)
where T : new()
{
conn.CheckNull(nameof(conn));
return(conn.ExecuteEntitiesAsync <T>(cmdText, parameters, CommandType.Text, transaction));
}
/// <summary>
/// Execute ExpandoObjects
/// </summary>
/// <param name="conn"></param>
/// <param name="cmdText"></param>
/// <param name="transaction"></param>
/// <returns></returns>
public static Task <IEnumerable <dynamic> > ExecuteExpandoObjectsAsync(this SQLiteConnection conn, string cmdText, SQLiteTransaction transaction)
{
conn.CheckNull(nameof(conn));
return(conn.ExecuteExpandoObjectsAsync(cmdText, null, CommandType.Text, transaction));
}
internal bool IsOnlyTransaction(SQLiteTransaction transaction)
{
return(m_transactions.Count == 1 && m_transactions.Peek() == transaction);
}
/// <summary>
/// Create command
/// </summary>
/// <param name="conn"></param>
/// <param name="cmdText"></param>
/// <param name="commandType"></param>
/// <param name="transaction"></param>
/// <param name="parameters"></param>
/// <returns></returns>
public static SQLiteCommand CreateCommand(this SQLiteConnection conn,
string cmdText, CommandType commandType, SQLiteTransaction transaction,
params SQLiteParameter[] parameters)
{
conn.CheckNull(nameof(conn));
var command = conn.CreateCommand();
command.CommandText = cmdText;
command.CommandType = commandType;
command.Transaction = transaction;
if (parameters is not null)
{
command.Parameters.AddRange(parameters);
}
return(command);
}