Работа с Firebird и Interbase в Visual Studio с примерами на c#

public void GetSingleValueFromSP()
{
      // Описание: GEN_ID, CommandType.StoredProcedure, out parameters, Firebird, Interbase, IBProvider, Firebird .Net провайдер
      using (OleDbConnection cn = ConnectionProvider.GetConnection())
      {
        cn.Open();
        OleDbTransaction trans = cn.BeginTransaction();

        OleDbCommand cmd = cn.CreateCommand();
        cmd.Transaction = trans;

        //set command type and procedure name
        cmd.CommandType = System.Data.CommandType.StoredProcedure;
        cmd.CommandText = "NEXT_ID";

        OleDbParameter param = cmd.Parameters.Add("ID", OleDbType.BSTR);
        param.Direction = System.Data.ParameterDirection.Output;

        Console.WriteLine(":{0}", param.Value);
        trans.Commit();
        cn.Close();
      }
}

public void ArrayReadWriteTest()
{
    // Описание: МАССИВЫ Firebird, Interbase, чтение и запись массивов c#, ADO Net
    OleDbConnection con = ConnectionProvider.CreateConnection();
    con.Open();
    OleDbTransaction trans = con.BeginTransaction();

    OleDbCommand cmd = new OleDbCommand(
    "select job_code, job_grade, job_country, job_title, language_req from job",
    con, trans);

    OleDbCommand cmd_upd = new OleDbCommand(
    "update job set language_req=:language_reg where \n" +
    "job_code=:job_code and job_grade=:job_grade and job_country=:job_country",
    con, trans);

    cmd_upd.Parameters.Add("language_req", OleDbType.Variant);
    cmd_upd.Parameters.Add("job_code", OleDbType.BSTR);
    cmd_upd.Parameters.Add("job_grade", OleDbType.BSTR);
    cmd_upd.Parameters.Add("job_country", OleDbType.BSTR);

    using (OleDbDataReader rdr = cmd.ExecuteReader())
    {
        while (rdr.Read())
        {
        Console.WriteLine("JOB TITLE:" + rdr["job_title"].ToString());

        //чтение массива
        object lang_obj_arr = rdr["language_req"];

        if (lang_obj_arr != DBNull.Value)
        {
            //преобразование к массиву
            //используем Array.CreateInstance для создания массива
            //из 5 элементов, с адресацией начиная с 1-го элемента, а не с 0
            short arr_lower_bound = 1;

            Array lang_str_arr = Array.CreateInstance(typeof(string), new int[] {5}, new int[] { arr_lower_bound });

            //копирование элементов в массив                         
            ((Array)lang_obj_arr).CopyTo(lang_str_arr, arr_lower_bound);

            for (int i = arr_lower_bound; i < lang_str_arr.Length + arr_lower_bound; i++)
            {
              //усечение символа \n на концах элементов массива
  	          string trimmed_value = lang_str_arr.GetValue(i).ToString().Replace("\n", "");
              lang_str_arr.SetValue(trimmed_value, i);

              //вывод значения
              if (lang_str_arr.GetValue(i).ToString() != "")
                  Console.WriteLine(lang_str_arr.GetValue(i));
            }

            //запись новых значений элементов массива без символа \n                       
            cmd_upd.Parameters["language_req"].Value = lang_str_arr;
            cmd_upd.Parameters["job_code"].Value = rdr["job_code"];
            cmd_upd.Parameters["job_grade"].Value = rdr["job_grade"];
            cmd_upd.Parameters["job_country"].Value = rdr["job_country"];

            //предача изменений в БД
            Assert.IsTrue(cmd_upd.ExecuteNonQuery() == 1);
         }
         else
            Console.WriteLine("No language specified");

         Console.WriteLine("");
       }
   }

   //откат сделанных изменений         
   trans.Rollback();
   con.Close();
}

public void BLOBReadWriteTest()
{
    // Описание: Работа с BLOB полями, чтение и запись блобов, Firebird c#, Interbase ADO Net
    OleDbConnection con = ConnectionProvider.CreateConnection();
    con.Open();
    OleDbTransaction trans = con.BeginTransaction();

    //BLOB Read command
    OleDbCommand cmd = new OleDbCommand(
    "select proj_id, proj_name,proj_desc from project", con, trans);

    //BLOB write command			
    OleDbCommand cmd_update = new OleDbCommand(
    "update project set proj_desc=:proj_desc where proj_id=:proj_id", con, trans);

    //create parameters with BSTR type
    cmd_update.Parameters.Add("proj_desc", OleDbType.BSTR);
    cmd_update.Parameters.Add("proj_id", OleDbType.BSTR);

    using (OleDbDataReader rdr = cmd.ExecuteReader())
    {
       while (rdr.Read())
       {
             //чтение BLOB 
             Console.WriteLine("PROJECT: " + rdr["proj_name"].ToString());
             Console.WriteLine(rdr["proj_desc"].ToString());

             //запись BLOB
             cmd_update.Parameters["proj_id"].Value = rdr["proj_id"];

             //каждый раз меняем регистр данных в BLOB поле
             string new_project_description = rdr["proj_desc"].ToString();
             if (new_project_description.ToUpper() != new_project_description)
                 new_project_description = new_project_description.ToUpper();
             else
                 new_project_description = new_project_description.ToLower();

             cmd_update.Parameters["proj_desc"].Value = new_project_description;
             Assert.AreEqual(1, cmd_update.ExecuteNonQuery());
  	    }
    }

    trans.Commit();
    con.Close();
}

  public void AutoCommitSessionTest()
  {
     // Описание: AutoCommit, AutoCommitLevel, автоматическое управление транзакциями, Interbase c#, Firebird ADO Net
     OleDbConnectionStringBuilder builder =
     ConnectionProvider.GetConnectionStringBuilder();
     builder.Add("auto_commit", true);
     builder.Add("auto_commit_level", Convert.ToInt32(System.Data.IsolationLevel.RepeatableRead));

     OleDbConnection con = new OleDbConnection(builder.ToString());
     con.Open();

     OleDbCommand cmd = new OleDbCommand("select count(*) from employee", con);
     Assert.IsTrue((int)cmd.ExecuteScalar() > 0);

     con.Close();
  }

public void InternalTransactionTest()
{
    //Описание: NESTED TRANSACTIONS, Firebird ADO .Net, C#, Firebird .Net провайдер
    OleDbConnectionStringBuilder builder = ConnectionProvider.GetConnectionStringBuilderFromUDL();

    //включить вложенные транзакции
    builder.Add("nested_trans", true);

    OleDbConnection con1 = new OleDbConnection(builder.ToString());
    con1.Open();

    //основная транзакция
    OleDbTransaction trans = con1.BeginTransaction();

    //добавить новую запись
    OleDbCommand cmd_insert = new OleDbCommand(
    "insert into country (country,currency) values (:country,:currency)", con1, trans);

    cmd_insert.Parameters.AddWithValue(":country", "Russia");
    cmd_insert.Parameters.AddWithValue(":currency", "Ruble");
    Assert.AreEqual(1, cmd_insert.ExecuteNonQuery());

    //запустить вложенную транзакцию
    OleDbTransaction internal_transaction = trans.Begin();

    //запустить вложенную транзакцию внутри вложенной
    OleDbTransaction internal_transaction2 = internal_transaction.Begin();

    //удалить запись во вложенно транзакции третьего уровня
    OleDbCommand cmd_delete = new OleDbCommand(
        "delete from country where country=?", con1, internal_transaction2);
    cmd_delete.Parameters.AddWithValue("?", "Russia");
    Assert.AreEqual(1, cmd_delete.ExecuteNonQuery());

    //откатить вложенную транзакцию третьего уровня
    internal_transaction2.Rollback();

    //проверить что запись не была удалена в тразакции второго уровня
    OleDbCommand cmd_check = new OleDbCommand(
        "select count(*) from country where country=?", con1, internal_transaction);

    cmd_check.Parameters.AddWithValue("?", "Russia");
    Assert.AreEqual (1, cmd_check.ExecuteScalar());

    //удалить запись
    cmd_delete.Transaction = internal_transaction;
    Assert.AreEqual(1, cmd_delete.ExecuteNonQuery());

    //зафиксировать изменения
    internal_transaction.Commit();

    //проверить в основной транзакции что запись удалена из БД
    cmd_check.Transaction = trans;
    Assert.AreEqual(0, cmd_check.ExecuteScalar());

    trans.Commit();
    con1.Close();
}

public void TransactionScopeTest()
{
  //TransactionScrope автоматически свяжет локальные транзакции с распределенной
  //В данном контексте будет две локальных транзакции на каждое подключение и одна  
  //распределенная.
  using (TransactionScope scope = new TransactionScope())
  {
     //автоматически будет создана локальная транзакция
     OleDbConnection con1 = ConnectionProvider.CreateConnection();
     con1.Open();

     //insert command
     OleDbCommand cmd_insert = new OleDbCommand(
     "insert into country (country,currency) values (:country,:currency)",con1);
     cmd_insert.Parameters.AddWithValue("country", "Russia");
     cmd_insert.Parameters.AddWithValue("currency", "Rouble");
     Assert.AreEqual(1, cmd_insert.ExecuteNonQuery());

     //автоматически будет создана ещё одна локальная транзакция 
     OleDbConnection con2 = ConnectionProvider.CreateConnection();
     con2.Open();

     cmd_insert.Connection = con2;
     cmd_insert.Parameters["country"].Value = "Latvia";
     cmd_insert.Parameters["currency"].Value = "Lat";
     Assert.AreEqual(1, cmd_insert.ExecuteNonQuery());

     //Фиксация распределенной транзакции   
     //Для всех локальных транзакций будет вызван метод Commit()
     scope.Complete();

  //Если ранее распределенная транзакция не была завершена для всех локальных     
  //транзакций будет вызван метод Rollback при вызове IDispose.Dispose()
  }

  //TransactionScope будет использовать локальную транзакцию
  //т.к. все команды выполняются в одном контексте
  using (TransactionScope scope = new TransactionScope())
  {
      OleDbConnection con1 = ConnectionProvider.CreateConnection();
      con1.Open();

      //проверяем, что в предыдущем контексте были добавлены записи
      OleDbCommand cmd_select = new OleDbCommand(
      "select count(*) from country where country=:country", con1);
      cmd_select.Parameters.Add("country", OleDbType.BSTR);

      //удаляем записи 
      OleDbCommand cmd_delete = new OleDbCommand(
      "delete from country where country=:country", con1);
      cmd_delete.Parameters.Add("country", OleDbType.BSTR);

      cmd_select.Parameters["country"].Value = "Russia";
      cmd_delete.Parameters["country"].Value = "Russia";
      Assert.AreEqual(1, cmd_select.ExecuteScalar());
      Assert.AreEqual(1, cmd_delete.ExecuteNonQuery());

      cmd_select.Parameters["country"].Value = "Latvia";
      cmd_delete.Parameters["country"].Value = "Latvia";
      Assert.AreEqual(1, cmd_select.ExecuteScalar());
      Assert.AreEqual(1, cmd_delete.ExecuteNonQuery());

      scope.Complete(); //commit   

   } //rollback           
}

public void SQLTransactionTest()
{
    //Описание: SET TRANSACTION READ ONLY, COMMIT RETAIN, Firebird ADO Net, C#
    OleDbConnection con1 = ConnectionProvider.CreateConnection();
    con1.Open();

    OleDbCommand cmd = new OleDbCommand(
    "SET TRANSACTION READ ONLY WAIT ISOLATION LEVEL READ COMMITTED", con1);
    cmd.ExecuteNonQuery();

    cmd.CommandText = "select count(*) from employee";
    Assert.AreNotEqual(0, cmd.ExecuteScalar());

    //поддтверждение транзакции с последующим использованием её контекста
    cmd.CommandText = "COMMIT RETAIN";
    cmd.ExecuteNonQuery();

    cmd.CommandText = "select count(*) from employee";
    Assert.AreNotEqual(0, cmd.ExecuteScalar());

    cmd.CommandText = "COMMIT";
    cmd.ExecuteNonQuery();

    con1.Close();
}

SAVEPOINT save_point_name

ROLLBACK TO SAVEPOINT save_point_name или COMMIT TO SAVEPOINT save_point_name

public void SavePointTest()
{
     //Описание: SAVEPOINT, ROLLBACK TO SAVEPOINT, Firebird .Net провайдер, Interbase c#
     OleDbConnection con1 = ConnectionProvider.CreateConnection();
     con1.Open();

     OleDbTransaction transaction = con1.BeginTransaction();

     OleDbCommand cmd_insert = new OleDbCommand(
     "insert into country (country,currency) values (:country,:currency)", con1, transaction);
     cmd_insert.Parameters.AddWithValue(":country", "Russia");
     cmd_insert.Parameters.AddWithValue(":currency", "Ruble");
     Assert.AreEqual(1, cmd_insert.ExecuteNonQuery());

     new OleDbCommand("SAVEPOINT AFTER_INSERT_POINT", con1, transaction).ExecuteNonQuery();

     //delete country in using 3-level internal transaction context
     OleDbCommand cmd_delete = new OleDbCommand(
         "delete from country where country=?", con1, transaction);
     cmd_delete.Parameters.AddWithValue("?", "Russia");
     Assert.AreEqual(1, cmd_delete.ExecuteNonQuery());

     new OleDbCommand("ROLLBACK TO SAVEPOINT AFTER_INSERT_POINT", con1, transaction).ExecuteNonQuery();

     //check what record was not deleted from Firebird database
     OleDbCommand cmd_check = new OleDbCommand(
         "select count(*) from country where country=?", con1, transaction);

     cmd_check.Parameters.AddWithValue("?", "Russia");
     Assert.AreEqual(1, cmd_check.ExecuteScalar());

     transaction.Rollback();
     con1.Close();
}

try
   {
   	  OleDbConnection con = new OleDbConnection("Provider=LCPI.IBProvider;Data Source=Empty;");
      con.Open();
      con.Close();
   }
   catch (OleDbException ole_ex)
   {
      foreach (OleDbError err in ole_ex.Errors)
              {
              Console.WriteLine("Message:      " + err.Message);
              Console.WriteLine("Native Error: " + err.NativeError);
              Console.WriteLine("Source:       " + err.Source);
              Console.WriteLine("SQL State   : " + err.SQLState);
              }
   }
   catch (Exception ex)
   {
       Console.WriteLine(ex.ToString());
   }

Message:      Неопределено обязательное свойство инициализации "Password".
Native Error: 0
Source:       LCPI.IBProvider.2
SQL State   :
Message:      Неопределено обязательное свойство инициализации "User ID".
Native Error: 0
Source:       LCPI.IBProvider.2
SQL State   :

   public void ReadPropertiesTest()
   {
      // Описание: работа с OleDbProperties в IBProvider, Firebird (Interbase) c#
      OleDbConnection con = ConnectionProvider.CreateConnection();
      con.Open();

      //OleDbConnection properties
      OleDbProperties properties = OleDbProperties.GetPropertiesFor(con);
      Assert.AreNotEqual(0, properties.Count);
      PrintProperties(properties);

      //OleDbCommand properties
      OleDbCommand cmd = new OleDbCommand("select * from country", con, con.BeginTransaction());

      properties = OleDbProperties.GetPropertiesFor(cmd);
      Assert.AreNotEqual(0, properties.Count);
      PrintProperties(properties);

      //Property from Rowset ole db group can be changed
      properties["Use Bookmarks"].Value = true;
      Assert.IsTrue(Convert.ToBoolean(properties["Use Bookmarks"].Value));

      //OleDbDataReader properties
      using (OleDbDataReader rdr = cmd.ExecuteReader())
      {
          properties = OleDbProperties.GetPropertiesFor(rdr);
          PrintProperties(properties);
      }

      con.Close();
   }

   private void PrintProperties(OleDbProperties properties)
   {
      foreach (OleDbProperty  prop in properties.Values)
               Console.WriteLine((prop.Required ==true ? "[r] " : "") +
                                  prop.Name + "=" + prop.ValueString);
}

public void OleDbServicesTest()
{
    const int connection_count = 50;

    //хранит результат работы по всем операциям
    Dictionary<string, double> timeResults = new Dictionary<string, double>();

    OleDbConnectionStringBuilder builder =
    ConnectionProvider.GetConnectionStringBuilderFromUDL();

    //OLE DB SERVISES = Все сервисы включены
    builder.OleDbServices = OleDbServicesValues.EnableAll;
    timeResults.Add(
    String.Format("OLE DB Services=EnableAll ({0})", builder.OleDbServices),
    DoConnections(builder, connection_count));

    //OLE DB SERVISES = все сервисы отключены         
    builder.OleDbServices = OleDbServicesValues.DisableAll;
    timeResults.Add(
    String.Format("OLE DB Services=DisableAll ({0})", builder.OleDbServices),
 	    DoConnections(builder, connection_count));

    //OLE DB SERVICES = все включено, за исключением клиентских курсоров
    //и работы за пределами сессии            
    builder.OleDbServices = (OleDbServicesValues.EnableAll &
                           ~ OleDbServicesValues.ClientCursor &
                           ~ OleDbServicesValues.AggregationAfterSession);
    timeResults.Add(
    String.Format("OLE DB Services=\n"+
                  "\tEnableAll & \n" +
                  "\t~ClientCursor & \n" +
                  "\t~AggregationAfterSession ({0})", builder.OleDbServices),
          DoConnections(builder, connection_count));

    foreach (string key in timeResults.Keys)
          Console.WriteLine(key + ". Seconds elapsed: " + timeResults[key]);
}

/// <summary>
/// Открывает и закрывает много подключений, а так же стартует транзакции
/// </summary>
/// <param name="builder"></param>
/// <param name="cnt_connection"></param>
/// <returns>Сколько секунд выполнялось</returns> 
private double DoConnections(OleDbConnectionStringBuilder builder,
     int cnt_connection)
{
    DateTime startTime = DateTime.Now;

    for (int i = 1; i <= cnt_connection; i++)
    {
        OleDbConnection con = new OleDbConnection(builder.ToString());
        con.Open();
        OleDbTransaction trans = con.BeginTransaction();
        trans.Commit();
        con.Close();
    }

    return DateTime.Now.Subtract(startTime).TotalSeconds;
}

public void FillDataSetFromDataAdapter()
{
   // Описание: Заполнение DataSet через OleDbDataAdapter, работа с Firebird, Interbase
   DataSet ds = new DataSet();

   using (System.Transactions.TransactionScope scope =
 		new System.Transactions.TransactionScope())
   {
      OleDbConnection con = ConnectionProvider.CreateConnection();
      con.Open();

      OleDbDataAdapter adapter =
           new OleDbDataAdapter("select * from EMPLOYEE", con);
      adapter.Fill(ds);

      Assert.IsTrue(ds.Tables[0].Rows.Count > 0);
      scope.Complete();
   }
}

public void FillDataSetFromDBReaderTest()
{
    // Описание: Заполнение DataSet через OleDbDataReader, ADO .Net компоненты Firebird и Interbase
    OleDbConnection con = ConnectionProvider.CreateConnection();
    con.Open();
    OleDbCommand cmd =
      new OleDbCommand("select * from EMPLOYEE",con,   con.BeginTransaction());

    DataSet ds = new DataSet();
    DataTable tbl = ds.Tables.Add("EMPLOYEE");

    using (OleDbDataReader reader =
                           cmd.ExecuteReader(CommandBehavior.CloseConnection))
    {
          ds.Load(reader, LoadOption.OverwriteChanges, tbl);
    }
}

public void GetDBReaderFromDataTable()
{
   // Описание: DataTableReader - последовательное, однонаправленное чтение виртуальной таблицы, ADO Net компоненты Interbase (Firebird)
   DataSet ds = new DataSet();
   DataTable tbl = ds.Tables.Add("EMPLOYEE");

   //загрузка данных в dataSet 
   OleDbConnection con = ConnectionProvider.CreateConnection();
   con.Open();
   OleDbTransaction trans = con.BeginTransaction();

   ds.Load(new OleDbCommand(
           "select * from EMPLOYEE",con,trans).ExecuteReader(),
           LoadOption.OverwriteChanges, tbl);

   //используем DataTable в режиме однонаправленного чтения
   this.PrintDBDataReader(new DataTableReader(tbl));

   //OleDbDataReader и подсоединенный режим
   this.PrintDBDataReader(
        new OleDbCommand("select * from EMPLOYEE", con,  trans).ExecuteReader());

   trans.Commit();
   con.Close();
}

/// <summary>
/// Выводит в консоль данные из DBDataReader
/// </summary>
/// <param name="reader"></param>
public void PrintDBDataReader(System.Data.Common.DbDataReader reader)
{
     while (reader.Read())
     {
        Console.WriteLine("*********************************");
        for (int i = 0; i < reader.FieldCount; i++)
           Console.WriteLine(reader.GetName(i) + "=" + reader[i].ToString());
     }

     reader.Close();
}

public void UpdateDataSet()
{
   // Описание: OleDbDataAdapter.Update(DataTable) - передача изменений в СУБД Firebird, Interbase c#
   DataSet ds = new DataSet();
   DataTable tbl = ds.Tables.Add("EMPLOYEE");

   OleDbConnection con = ConnectionProvider.CreateConnection();
   con.Open();
   OleDbDataAdapter adapter = new OleDbDataAdapter("select * from EMPLOYEE", con);
   adapter.SelectCommand.Transaction = con.BeginTransaction();
   adapter.Fill(tbl);

   //вносим изменения в DataSet
   foreach (DataRow row in tbl.Rows)
      row["FIRST_NAME"] = row["FIRST_NAME"].ToString().ToUpper();

   //генерируем команды для операций update, insert и delete 
   OleDbCommandBuilder cmd_builder = new OleDbCommandBuilder(adapter);
   adapter.DeleteCommand = cmd_builder.GetDeleteCommand();
   adapter.UpdateCommand = cmd_builder.GetUpdateCommand();
   adapter.InsertCommand = cmd_builder.GetInsertCommand();

   //обновление данных
   adapter.Update(tbl);

   //откат сделанных изменений
   adapter.SelectCommand.Transaction.Rollback();
   con.Close();
}