public Transaction(SQLiteTransaction transaction)
        {
            if (_base == null)
                throw new ArgumentNullException("transaction");

            _base = transaction;
        }

        public SQLiteCommand CreateAddProductCommand(SQLiteConnection conn, SQLiteTransaction transaction)
        {
            var cmd = new SQLiteCommand(_sql, conn, transaction);
            CreateParameters(cmd);

            return cmd;
        }

        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 SQLiteTransaction(SQLiteDatabase database, IsolationLevel level, SQLiteSettings settings)
 {
   _database = database;
   _settings = settings;
   _connection = _database.ConnectionPool.GetConnection();
   _transaction = _connection.BeginTransaction(level);
 }

        public SQLiteCommand GetCommandOnCurrentConnect(String commandText, out SQLiteTransaction sqLiteTransaction){
            var connection = GetCurrentConnection();

            sqLiteTransaction = connection.BeginTransaction();

            return new SQLiteCommand(commandText, connection, sqLiteTransaction);
        }

		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 SQLiteCommand(string commandText, SQLiteConnection connection, SQLiteTransaction transaction)
		{
			CommandText = commandText;
			DbConnection = connection;
			DbTransaction = transaction;
			m_parameterCollection = new SQLiteParameterCollection();
		}

		private SQLiteCommand GetCommand(string sql, SQLiteTransaction transaction)
		{
			return new SQLiteCommand(
				sql,
				this.Connection,
				transaction
			);
		}

		public void SetCommandConstraints(
			string                       clause,
			IEnumerable<SQLiteParameter> parameters,
			SQLiteTransaction            transaction = null
		)
		{
			this._clause      = clause;
			this._parameters  = parameters;
			this._transaction = transaction;
		}

        public SQLiteMonTransaction(SQLiteTransaction transaction)
        {
            this.wrappedTrans = transaction;

            StackTrace trace = new StackTrace(true);

            lock (readerInfoLock)
            {
                readerInfo.Add(this.wrappedTrans, trace.ToString());
            }
        }

 /// <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 ReplaceCommand(
			SQLiteConnection  connection,
			TableDefinition   tableDefinition,
			SQLiteTransaction transaction = null
		) : base(
				connection,
				tableDefinition
			)
		{
			this._rows        = new List<ITableRow>();
			this._transaction = transaction;
		}

        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 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();
        }

        /// <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 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);
    }

    ///////////////////////////////////////////////////////////////////////////////////////////////

    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;
        }
    }

            private void init(string connString) {

                connection = new SQLiteConnection(connString);
                connection.Open();
                //connection.ChangeDatabase(Server.MySQLDatabaseName);

                transaction = connection.BeginTransaction();
            }