/// <summary>Usuwa z bazy danych rzędy, których wartości w wybranych kolumnach są równe podanym w parametrze.</summary>
        /// <param name="where">
        /// <para>Zawiera wartości, jakie znajdują się w usuwanych rekordach.</para> 
        /// <para>Wartości dla kolumn, dla których nie sprawdzamy wartości mają pozostać jako null.</para>
        /// </param>
        public void delete(WierszTabeli where)
        {
            using (SqlCeConnection connection = new SqlCeConnection(connectionString))
            {
                SqlCeCommand delete = new SqlCeCommand("DELETE FROM " + where.NazwaTabeli + klauzulaWhere(where), connection);
                connection.Open();
                SqlCeTransaction traksakcja = connection.BeginTransaction();

                try
                {
                    delete.ExecuteNonQuery();
                    traksakcja.Commit();
                }
                catch (SqlCeException SQLe)
                {
                    InvalidOperationException e = new InvalidOperationException("Wystąpił błąd przy próbie wykonania polecenia " + delete.CommandText, SQLe);
                    try
                    {
                        traksakcja.Rollback();
                    }
                    catch (InvalidOperationException IOe)
                    {
                        e = new InvalidOperationException("Wstąpił błąd przy próbie cofnięcia transakcji \npo błędzie polecenia " + delete.CommandText, IOe);
                    }
                    throw e;
                }
            }
        }
 /// <summary>Tworzy nowy WierszTabeli będący kopią podanego.</summary>
 public WierszTabeli(WierszTabeli wiersz)
 {
     this.NazwaTabeli = wiersz.NazwaTabeli;
     this.zawartosc = new Dictionary<string, object>(wiersz.zawartosc);
     if (NazwaTabeli == "SchemaTable") //Kopiowany wiersz trzyma informacje o tabeli.
         this.typyKolumn = new Dictionary<string, Type>(wiersz.typyKolumn);
     else //Zwykły wiersz, którego typyKolumn są referencją do wartości w cache.
         this.typyKolumn = wiersz.typyKolumn;
 }
        public void KonstruktorWierszTabeli()
        {
            using (ShimsContext.Create())
            {
                var wiersz = CreateStandardWierszTabeli();
                var wiersz2 = new WierszTabeli(wiersz);

                Assert.AreEqual(wiersz.ToString(), wiersz2.ToString());
                Assert.AreNotSame(wiersz, wiersz2);
                Assert.AreNotSame(wiersz.Wartosci, wiersz2.Wartosci);
            }
        }
        public void KonstruktorNazwaTabeli()
        {
            using (ShimsContext.Create())
            {
                CreateSchemaInfo();

                var wiersz = new WierszTabeli("NazwaTabeli");
                Assert.AreEqual("NazwaTabeli\nID, StringColumn\n", wiersz.ToString());
                Assert.AreEqual("NazwaTabeli", wiersz.NazwaTabeli);
            }
        }
 /// <summary>Zmienia format wartości w wierszu na zgodny z SQL Server CE</summary>
 static WierszTabeli opakujWartosci(WierszTabeli wiersz)
 {
     WierszTabeli wynik = new WierszTabeli(wiersz);
     foreach (string kolumna in wiersz.NazwyKolumn)
     {
         wynik[kolumna] = opakujWartosc(wiersz[kolumna]);
     }
     return wynik;
 }
        /// <summary>Konstruuje klauzulę WHERE dla podanego wiersza</summary>
        static string klauzulaWhere(WierszTabeli zapytanie)
        {
            List<string> warunki = new List<string>();
            zapytanie = opakujWartosci(zapytanie);
            foreach (string kolumna in zapytanie.NazwyKolumn)
            {
                if (zapytanie[kolumna] != null)
                {
                    warunki.Add(kolumna + " = " + zapytanie[kolumna]);
                }
            }

            if (warunki.Count == 0)
                return "";
            else
                return " WHERE (" + string.Join(" AND ", warunki) + ")";
        }
        /// <summary>Zmienia dane w rzędach, w których wartości w wybranych kolumnach są równe podanym w parametrze where 
        /// na te podane w parametrze noweDane.</summary>
        /// <param name="where">
        /// <para>Zawiera wartości, jakie znajdują się w zmienianych rekordach.</para> 
        /// <para>Wartości dla kolumn, dla których nie sprawdzamy wartości mają pozostać jako null.</para>
        /// </param>
        /// <param name="noweDane">
        /// <para>Zawiera wartości, jakie znajdą się w zmienianych rekordach.</para> 
        /// <para>Wartości dla kolumn, dla których nie zmianiamy wartości mają pozostać jako null.</para>
        /// </param>
        public void update(WierszTabeli where, WierszTabeli noweDane)
        {
            using (SqlCeConnection connection = new SqlCeConnection(connectionString))
            {
                SqlCeCommand update = new SqlCeCommand("UPDATE " + noweDane.NazwaTabeli
                    + klauzulaWhere(noweDane).Replace("WHERE", "SET").Replace("(","").Replace(")","")
                    + klauzulaWhere(where)
                    , connection);
                //System.Windows.Forms.MessageBox.Show(update.CommandText);
                connection.Open();
                SqlCeTransaction traksakcja = connection.BeginTransaction();

                try
                {
                    update.ExecuteNonQuery();
                    traksakcja.Commit();
                }
                catch (SqlCeException SQLe)
                {
                    InvalidOperationException e = new InvalidOperationException("Wystąpił błąd przy próbie wykonania polecenia " + update.CommandText, SQLe);
                    try
                    {
                        traksakcja.Rollback();
                    }
                    catch (InvalidOperationException IOe)
                    {
                        e = new InvalidOperationException("Wstąpił błąd przy próbie cofnięcia transakcji \npo błędzie polecenia " + update.CommandText, IOe);
                    }
                    throw e;
                }

            }
        }
        /// <summary>Zwraca listę rekordów, których wartości w wybranych kolumnach są równe podanym w parametrze.</summary>
        /// <param name="where">
        /// <para>Zawiera wartości, jakie znajdują się w zwracanych rekordach.</para> 
        /// <para>Wartości dla kolumn, dla których nie sprawdzamy wartości mają pozostać jako null.</para>
        /// </param>
        /// <returns>Lista rekordów odpowiadających zapytaniu.</returns>
        public IList<WierszTabeli> select(WierszTabeli where)
        {
            IList<WierszTabeli> wynik = new List<WierszTabeli>();

            using (SqlCeConnection connection = new SqlCeConnection(connectionString))
            {
                SqlCeCommand select;
                {
                    string selectText = "SELECT " + string.Join(", ", where.NazwyKolumn)
                    + " FROM " + where.NazwaTabeli + klauzulaWhere(where);
                    select = new SqlCeCommand(selectText, connection);
                }
                connection.Open();
                SqlCeDataReader reader;
                try
                {
                    reader = select.ExecuteReader();
                }
                catch (SqlCeException e)
                {

                    throw new EvaluateException("Wystąpił błąd przy wykonywaniu zapytania " + select.CommandText, e);
                }

                using (DataTable tabela = new DataTable())
                {
                    tabela.Load(reader);
                    foreach (DataRow wiersz in tabela.Rows)
                    {
                        wynik.Add(new WierszTabeli(wiersz));
                    }
                }

                reader.Close();
            }

            return wynik;
        }
        /// <summary>Dodaje podany wiersz do odpowiedniej tabeli.</summary>
        /// <param name="nowyWiersz">Wiersz do dodania.</param>
        public void insert(WierszTabeli nowyWiersz)
        {
            nowyWiersz = opakujWartosci(nowyWiersz);
            using (SqlCeConnection connection = new SqlCeConnection(connectionString))
            {
                SqlCeCommand insert = new SqlCeCommand("INSERT INTO " + nowyWiersz.NazwaTabeli
                    + "(" + string.Join(", ", nowyWiersz.NazwyKolumn) + ") "
                    + " VALUES (" + string.Join(", ",nowyWiersz.Wartosci) + ")"
                    , connection);
                connection.Open();
                SqlCeTransaction traksakcja = connection.BeginTransaction();

                try
                {
                    insert.ExecuteNonQuery();
                    traksakcja.Commit();
                }
                catch (SqlCeException SQLe)
                {
                    InvalidOperationException e = new InvalidOperationException("Wystąpił błąd przy próbie wykonania polecenia " + insert.CommandText, SQLe);
                    try
                    {
                        traksakcja.Rollback();
                    }
                    catch (InvalidOperationException IOe)
                    {
                        e = new InvalidOperationException("Wstąpił błąd przy próbie cofnięcia transakcji \npo błędzie polecenia " + insert.CommandText, IOe);
                    }
                    throw e;
                }

            }
        }