SQL Server CE 4.0 performance-Vergleich

Meiner Meinung nach, ist es falsch, vergleichen Sie die eingebettete Datenbank (wie SQL CE) vs. server-Seite-relationale Datenbank (wie der ganze rest, außer für SQLite und die Embedded-version von Firebird).

Der wesentliche Unterschied zwischen Ihnen ist, dass die Allzweck-server-side-relationale Datenbanken (wie MS SQL, MySQL, Firebird Classic and SuperServer etc.) installiert sind als Unabhängiger service-und laufen außerhalb der Reichweite Ihres Haupt-Anwendung. Das ist, warum Sie durchführen können viel besser, weil die tatsächliche Unterstützung für multi-core und multi-CPU-Architekturen unter Verwendung der OS-Funktionen wie pre-caching, VSS etc. erhöhen den Durchsatz bei intensivem Datenbank Betrieb und kann behaupten, so viel Speicher wie Ihr Betriebssystem, kann sich für einen einzelnen Dienst/Anwendung. Es bedeutet auch, dass die performance-Indikatoren sind mehr oder weniger unabhängig von Ihrer Anwendung, kann aber weitgehend davon abhängen, Ihre hardware. In dieser Hinsicht würde ich sagen, dass die server-Versionen der Datenbank werden immer mehr Leistung im Vergleich zu den embedded lieben.

SQL CE (zusammen mit Firebird Embedded, SQLite, TurboSQL und einige andere) sind embedded-DB-engines, was bedeutet, dass die komplette Datenbank ist verpackt in einem einzigen (oder maximal 2) DLL-Dateien, die verteilt werden, die zusammen mit Ihrer Anwendung. Aufgrund der offensichtlichen Größe Einschränkungen (möchten Sie vertreiben eine 30-MB-DLL zusammen mit Ihren 2-3 MB lange Anwendung?) Sie auch läuft direkt im Kontext Ihrer Anwendung und die insgesamt Speicher und performance für data access-Operationen werden gemeinsam mit anderen teilen der Anwendung -- das betrifft sowohl die verfügbaren Speicher, CPU-Zeit, Festplatten-Durchsatz etc. Mit einem rechenintensiven threads laufen parallel Ihre Daten zugreifen-thread könnte dazu führen, dramatischen Rückgang der Datenbank-performance.

Aufgrund der unterschiedlichen Einsatzbereiche diese Datenbanken haben unterschiedliche palette von Optionen: server-db bieten umfangreiche Benutzer-und Rechte-management, Unterstützung für die Ansichten und gespeicherten Prozeduren in der Erwägung, dass eingebettete Datenbank, die sich normalerweise keine Unterstützung für Benutzer-und Rechte-management und haben nur begrenzte Unterstützung für die Ansichten und gespeicherte Prozeduren (letztere verlieren die meisten Ihrer Vorteile, die auf der server-Seite). Der Datendurchsatz ist eine übliche Engpässe von RDBMS, server-Versionen sind in der Regel installiert auf Stripeset-RAID-volumes, in der Erwägung, dass embedded-DB sind oft Speicher-orientiert (versuchen zu halten, alle aktuellen Daten im Speicher) und minimieren die Speicherung der Daten Zugriffen.

So, was Sinn machen würde ist wahrscheinlich zu vergleichen verschiedene embedded RDBMS .Net für Ihre performance, wie Sie MS SQL CE 4.0, SQLite, Firebird Embedded, TurboSQL. ich würde nicht erwarten, dass drastische Unterschiede während der üblichen nicht-peak-Betrieb, in der Erwägung, dass einige Datenbanken möglicherweise bieten eine bessere Unterstützung für große BLOBs, die durch die bessere integration mit OS.

-- update --

Ich wieder meine letzten Worte, für meine schnelle Umsetzung zeigt sehr interessante Ergebnisse.

Schrieb ich eine kurze Konsole-Anwendung um test-Daten-Anbietern, hier ist der source-code für Sie, wenn Sie wollen, mit Ihnen zu Experimentieren, auf Ihre eigenen.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data.SQLite;
using System.Data.SqlServerCe;
using System.Data.Common;

namespace TestSQL
{
    class Program
    {
        const int NUMBER_OF_TESTS = 1000;

        private static string create_table;

        private static string create_table_sqlce =  "CREATE TABLE Test ( id integer not null identity primary key, textdata nvarchar(500));";
        private static string create_table_sqlite = "CREATE TABLE Test ( id integer not null primary key, textdata nvarchar(500));";

        private static string drop_table = "DROP TABLE Test";
        private static string insert_data = "INSERT INTO Test (textdata) VALUES ('{0}');";
        private static string read_data = "SELECT textdata FROM Test WHERE id = {0}";
        private static string update_data = "UPDATE Test SET textdata = '{1}' WHERE id = {0}";
        private static string delete_data = "DELETE FROM Test WHERE id = {0}";

        static Action<DbConnection> ACreateTable = (a) => CreateTable(a);
        static Action<DbConnection> ATestWrite = (a) => TestWrite(a, NUMBER_OF_TESTS);
        static Action<DbConnection> ATestRead = (a) => TestRead(a, NUMBER_OF_TESTS);
        static Action<DbConnection> ATestUpdate = (a) => TestUpdate(a, NUMBER_OF_TESTS);
        static Action<DbConnection> ATestDelete = (a) => TestDelete(a, NUMBER_OF_TESTS);
        static Action<DbConnection> ADropTable = (a) => DropTable(a);

        static Func<Action<DbConnection>,DbConnection, TimeSpan> MeasureExecTime = (a,b) => { var start = DateTime.Now; a(b); var finish = DateTime.Now; return finish - start; };

        static Action<string, TimeSpan> AMeasureAndOutput = (a, b) => Console.WriteLine(a, b.TotalMilliseconds);

        static void Main(string[] args)
        {
            // opening databases
            SQLiteConnection.CreateFile("sqlite.db");
            SQLiteConnection sqliteconnect = new SQLiteConnection("Data Source=sqlite.db");
            SqlCeConnection sqlceconnect = new SqlCeConnection("Data Source=sqlce.sdf");

            sqlceconnect.Open();
            sqliteconnect.Open();

            Console.WriteLine("=Testing CRUD performance of embedded DBs=");
            Console.WriteLine(" => Samplesize: {0}", NUMBER_OF_TESTS);

            create_table = create_table_sqlite;
            Console.WriteLine("==Testing SQLite==");
            DoMeasures(sqliteconnect);

            create_table = create_table_sqlce;
            Console.WriteLine("==Testing SQL CE 4.0==");
            DoMeasures(sqlceconnect);



            Console.ReadKey();

        }

        static void DoMeasures(DbConnection con)
        {
            AMeasureAndOutput("Creating table: {0} ms", MeasureExecTime(ACreateTable, con));
            AMeasureAndOutput("Writing data: {0} ms", MeasureExecTime(ATestWrite, con));
            AMeasureAndOutput("Updating data: {0} ms", MeasureExecTime(ATestUpdate, con));
            AMeasureAndOutput("Reading data: {0} ms", MeasureExecTime(ATestRead, con));
            AMeasureAndOutput("Deleting data: {0} ms", MeasureExecTime(ATestDelete, con));
            AMeasureAndOutput("Dropping table: {0} ms", MeasureExecTime(ADropTable, con));
        }



        static void CreateTable(DbConnection con)
        {
            var sqlcmd = con.CreateCommand();
            sqlcmd.CommandText = create_table;
            sqlcmd.ExecuteNonQuery();
        }

        static void TestWrite(DbConnection con, int num)
        {
            for (; num-- > 0; )
            {
                var sqlcmd = con.CreateCommand();
                sqlcmd.CommandText = string.Format(insert_data,Guid.NewGuid().ToString());
                sqlcmd.ExecuteNonQuery();
            }

        }

        static void TestRead(DbConnection con, int num)
        {
            Random rnd = new Random(DateTime.Now.Millisecond);
            for (var max = num; max-- > 0; )
            {
                var sqlcmd = con.CreateCommand();
                sqlcmd.CommandText = string.Format(read_data, rnd.Next(1,num-1));
                sqlcmd.ExecuteNonQuery();
            }
        }

        static void TestUpdate(DbConnection con, int num)
        {
            Random rnd = new Random(DateTime.Now.Millisecond);
            for (var max = num; max-- > 0; )
            {
                var sqlcmd = con.CreateCommand();
                sqlcmd.CommandText = string.Format(update_data, rnd.Next(1, num - 1), Guid.NewGuid().ToString());
                sqlcmd.ExecuteNonQuery();
            }
        }

        static void TestDelete(DbConnection con, int num)
        {
            Random rnd = new Random(DateTime.Now.Millisecond);
            var order = Enumerable.Range(1, num).ToArray<int>();
            Action<int[], int, int> swap = (arr, a, b) => { int c = arr[a]; arr[a] = arr[b]; arr[b] = c; };

            // shuffling the array
            for (var max=num; max-- > 0; ) swap(order, rnd.Next(0, num - 1), rnd.Next(0, num - 1));


            foreach(int index in order)
            {
                var sqlcmd = con.CreateCommand();
                sqlcmd.CommandText = string.Format(delete_data, index);
                sqlcmd.ExecuteNonQuery();
            }
        }

        static void DropTable(DbConnection con)
        {
            var sqlcmd = con.CreateCommand();
            sqlcmd.CommandText = drop_table;
            sqlcmd.ExecuteNonQuery();
        }


    }
}

Notwendige Haftungsausschluss:

1. Bekam ich diese Ergebnisse auf meine Maschine: Dell Precision WorkStation T7400 ausgestattet mit 2 Intel Xeon E5420-CPUs und 8 GB RAM unter 64bit Win7 Enterprise.
2. Ich benutzte die Standard-Einstellungen für beide DBs mit dem connection string "Data Source=database_file_name".
3. Ich verwendet die neuesten Versionen von SQL CE 4.0 und SQLite/System.Daten.SQLite (ab heute, 3. Juni 2011).

Hier sind die Ergebnisse für zwei verschiedene Proben:

> =Testen, CRUD-performance embedded DBs= 
> => Samplesize: 200 
> ==Testen SQLite== 
> Erstellen von Tabellen: 396.0396 ms 
> Schreiben von Daten: 22189.2187 ms 
> Aktualisieren von Daten: 23591.3589 ms 
> Lesen von Daten: 21.0021 ms 
> Löschen von Daten: 20963.0961 ms 
> Drop table: 85.0085 ms 

> ==Testen von SQL CE 4.0== 
> Erstellen von Tabellen: 16.0016 ms 
> Schreiben von Daten: 25.0025 ms 
> Aktualisieren von Daten: 56.0056 ms 
> Lesen von Daten: 28.0028 ms 
> Löschen von Daten: 53.0053 ms 
> Drop table: 11.0011 ms 

... und ein etwas größeres Beispiel:

=Test, CRUD-performance embedded DBs= 
=> Samplesize: 1000 
==Prüfung SQLite== 
Erstellen von Tabellen: 93.0093 ms 
Schreiben von Daten: 116632.6621 ms 
Aktualisierung der Daten: 104967.4957 ms 
Lesen von Daten: 134.0134 ms 
Daten löschen: 107666.7656 ms 
Drop table: 83.0083 ms 

==Prüfung SQL CE 4.0== 
Erstellen von Tabellen: 16.0016 ms 
Schreiben von Daten: 128.0128 ms 
Aktualisierung der Daten: 307.0307 ms 
Lesen von Daten: 164.0164 ms 
Daten löschen: 306.0306 ms 
Drop table: 13.0013 ms 

So, wie Sie sehen können, jedes schreiben-Operationen (create, update, delete) erfordern fast 1000x mehr Zeit in SQLite im Vergleich zu SQLCE. Es spiegelt nicht unbedingt die Allgemeine schlechte performance der Datenbank und kann mit der folgenden:

1. Die Daten-provider, die ich für SQLite ist der System.Daten.SQLite, das ist eine gemischte assembly mit verwaltetem und nicht verwaltetem code (SQLite ist ursprünglich vollständig in C geschrieben und die DLL stellt nur Bindungen). Wahrscheinlich P/Invoke und Daten-Marshalling frisst ein gutes Stück von der Betriebszeit.
2. Wahrscheinlich SQLCE 4.0 speichert alle Daten im Speicher standardmäßig in der Erwägung, dass SQLite spült die meisten der änderungen der Daten direkt auf die Festplatte Speicher jedes mal, wenn die änderung passiert. Eine kann-Versorgung Hunderte von Parametern, die für beide Datenbanken über connection string und optimieren Sie diese entsprechend.
3. Habe ich eine Reihe von Einzel-Abfragen zum testen der DB. Zumindest SQLCE unterstützt bulk-Operationen über spezielle .Net-Klassen, die wäre besser geeignet, hier. Wenn SQLite unterstützt Sie auch (sorry, ich bin kein Experte hier, und meine schnelle Suche ergab nichts passendes gefunden) es wäre schön, Sie zu vergleichen, wie gut.
4. Habe ich beobachtet, dass viele Probleme mit SQLite auf x64-Computern (unter Verwendung der gleichen .Netz-adapter): vom Daten-Verbindung geschlossen wird unerwartet zu Datenbank-Datei Korruption. Ich nehme an, es gibt einige Stabilität Probleme mit der Daten-adapter oder mit der Bibliothek selbst.

InformationsquelleAutor

Weil ich habe eine echte harte Zeit mit Alaudo tests, test-Ergebnisse, und letztlich mit seiner Schlussfolgerung, ich ging voran und spielte ein bisschen mit seinem Programm und kam mit einer modifizierten version.

Er testet jedes der folgenden 10-mal und Ausgänge die durchschnittlichen Zeiten:

• sqlite ohne Transaktionen, mit Standard-jounal_mode
• mit sqlite Transaktionen, Verwendung von Standard-journal_mode
• sqlite ohne Transaktionen mit WAL jounal_mode
• sqlite mit Transaktionen mit WAL journal_mode
• sqlce ohne Transaktionen
• sqlce mit Transaktionen

Hier ist das Programm (es ist ein Klasse eigentlich):

using System;
using System.Collections.Generic;
using System.Data.Common;
using System.Data.SqlServerCe;
using System.Data.SQLite;
using System.Diagnostics;
using System.IO;
using System.Linq;

class SqliteAndSqlceSpeedTesting
{
    class Results
    {
        public string test_details;
        public long create_table_time, insert_time, update_time, select_time, delete_time, drop_table_time;
    }

    enum DbType { Sqlite, Sqlce };

    const int NUMBER_OF_TESTS = 200;
    const string create_table_sqlite = "CREATE TABLE Test (id integer not null primary key, textdata nvarchar(500));";
    const string create_table_sqlce = "CREATE TABLE Test (id integer not null identity primary key, textdata nvarchar(500));";
    const string drop_table = "DROP TABLE Test";
    const string insert_data = "INSERT INTO Test (textdata) VALUES ('{0}');";
    const string read_data = "SELECT textdata FROM Test WHERE id = {0}";
    const string update_data = "UPDATE Test SET textdata = '{1}' WHERE id = {0}";
    const string delete_data = "DELETE FROM Test WHERE id = {0}";

    public static void RunTests()
    {
        List<Results> results_list = new List<Results>();

        for (int i = 0; i < 10; i++) {
            results_list.Add(RunTest(DbType.Sqlite, false, false));
            results_list.Add(RunTest(DbType.Sqlite, false, true));
            results_list.Add(RunTest(DbType.Sqlite, true, false));
            results_list.Add(RunTest(DbType.Sqlite, true, true));
            results_list.Add(RunTest(DbType.Sqlce, false));
            results_list.Add(RunTest(DbType.Sqlce, true));                
        }

        foreach (var test_detail in results_list.GroupBy(r => r.test_details)) {
            Console.WriteLine(test_detail.Key);
            Console.WriteLine("Creating table: {0} ms", test_detail.Average(r => r.create_table_time));
            Console.WriteLine("Inserting data: {0} ms", test_detail.Average(r => r.insert_time));
            Console.WriteLine("Updating data: {0} ms", test_detail.Average(r => r.update_time));
            Console.WriteLine("Selecting data: {0} ms", test_detail.Average(r => r.select_time));
            Console.WriteLine("Deleting data: {0} ms", test_detail.Average(r => r.delete_time));
            Console.WriteLine("Dropping table: {0} ms", test_detail.Average(r => r.drop_table_time));
            Console.WriteLine();
        }
    }

    static Results RunTest(DbType db_type, bool use_trx, bool use_wal = false)
    {
        DbConnection conn = null;
        if (db_type == DbType.Sqlite)
            conn = GetConnectionSqlite(use_wal);
        else
            conn = GetConnectionSqlce();

        Results results = new Results();
        results.test_details = string.Format("Testing: {0}, transactions: {1}, WAL: {2}", db_type, use_trx, use_wal);
        results.create_table_time = CreateTable(conn, db_type);
        results.insert_time = InsertTime(conn, use_trx);
        results.update_time = UpdateTime(conn, use_trx);
        results.select_time = SelectTime(conn, use_trx);
        results.delete_time = DeleteTime(conn, use_trx);
        results.drop_table_time = DropTableTime(conn);
        conn.Close();
        return results;
    }

    static DbConnection GetConnectionSqlite(bool use_wal)
    {
        SQLiteConnection conn = new SQLiteConnection("Data Source=sqlite.db");
        if (!File.Exists(conn.Database))
            SQLiteConnection.CreateFile("sqlite.db");
        conn.Open();
        if (use_wal) {
            var command = conn.CreateCommand();
            command.CommandText = "PRAGMA journal_mode=WAL";
            command.ExecuteNonQuery();
        }
        return conn;
    }

    static DbConnection GetConnectionSqlce()
    {
        SqlCeConnection conn = new SqlCeConnection("Data Source=sqlce.sdf");
        if (!File.Exists(conn.Database))
            using (var sqlCeEngine = new SqlCeEngine("Data Source=sqlce.sdf"))
                sqlCeEngine.CreateDatabase();
        conn.Open();
        return conn;
    }

    static long CreateTable(DbConnection con, DbType db_type)
    {
        Stopwatch sw = Stopwatch.StartNew();
        var sqlcmd = con.CreateCommand();
        if (db_type == DbType.Sqlite)
            sqlcmd.CommandText = create_table_sqlite;
        else
            sqlcmd.CommandText = create_table_sqlce;
        sqlcmd.ExecuteNonQuery();
        return sw.ElapsedMilliseconds;
    }

    static long DropTableTime(DbConnection con)
    {
        Stopwatch sw = Stopwatch.StartNew();
        var sqlcmd = con.CreateCommand();
        sqlcmd.CommandText = drop_table;
        sqlcmd.ExecuteNonQuery();
        return sw.ElapsedMilliseconds;
    }

    static long InsertTime(DbConnection con, bool use_trx)
    {
        Stopwatch sw = Stopwatch.StartNew();
        var sqlcmd = con.CreateCommand();
        DbTransaction trx = null;
        if (use_trx) {
            trx = con.BeginTransaction();
            sqlcmd.Transaction = trx;
        }
        for (int i = 0; i < NUMBER_OF_TESTS; i++) {
            sqlcmd.CommandText = string.Format(insert_data, Guid.NewGuid().ToString());
            sqlcmd.ExecuteNonQuery();
        }
        if (trx != null)
            trx.Commit();
        return sw.ElapsedMilliseconds;
    }

    static long SelectTime(DbConnection con, bool use_trx)
    {
        Stopwatch sw = Stopwatch.StartNew();
        var sqlcmd = con.CreateCommand();
        DbTransaction trx = null;
        if (use_trx) {
            trx = con.BeginTransaction();
            sqlcmd.Transaction = trx;
        }
        Random rnd = new Random(DateTime.Now.Millisecond);
        for (var max = NUMBER_OF_TESTS; max-- > 0; ) {
            sqlcmd.CommandText = string.Format(read_data, rnd.Next(1, NUMBER_OF_TESTS - 1));
            sqlcmd.ExecuteNonQuery();
        }
        if (trx != null)
            trx.Commit();
        return sw.ElapsedMilliseconds;
    }

    static long UpdateTime(DbConnection con, bool use_trx)
    {
        Stopwatch sw = Stopwatch.StartNew();
        var sqlcmd = con.CreateCommand();
        DbTransaction trx = null;
        if (use_trx) {
            trx = con.BeginTransaction();
            sqlcmd.Transaction = trx;
        }
        Random rnd = new Random(DateTime.Now.Millisecond);
        for (var max = NUMBER_OF_TESTS; max-- > 0; ) {
            sqlcmd.CommandText = string.Format(update_data, rnd.Next(1, NUMBER_OF_TESTS - 1), Guid.NewGuid().ToString());
            sqlcmd.ExecuteNonQuery();
        }
        if (trx != null)
            trx.Commit();
        return sw.ElapsedMilliseconds;
    }

    static long DeleteTime(DbConnection con, bool use_trx)
    {
        Stopwatch sw = Stopwatch.StartNew();
        Random rnd = new Random(DateTime.Now.Millisecond);
        var order = Enumerable.Range(1, NUMBER_OF_TESTS).ToArray<int>();
        Action<int[], int, int> swap = (arr, a, b) => { int c = arr[a]; arr[a] = arr[b]; arr[b] = c; };
        var sqlcmd = con.CreateCommand();
        DbTransaction trx = null;
        if (use_trx) {
            trx = con.BeginTransaction();
            sqlcmd.Transaction = trx;
        }
        // shuffling the array
        for (var max = NUMBER_OF_TESTS; max-- > 0; ) swap(order, rnd.Next(0, NUMBER_OF_TESTS - 1), rnd.Next(0, NUMBER_OF_TESTS - 1));

        foreach (int index in order) {
            sqlcmd.CommandText = string.Format(delete_data, index);
            sqlcmd.ExecuteNonQuery();
        }
        if (trx != null)
            trx.Commit();
        return sw.ElapsedMilliseconds;
    }
}

Hier sind die zahlen, die ich bekomme:

Testing: Sqlite, transactions: False, WAL: False
Creating table: 24.4 ms
Inserting data: 3084.7 ms
Updating data: 3147.8 ms
Selecting data: 30 ms
Deleting data: 3182.6 ms
Dropping table: 14.5 ms

Testing: Sqlite, transactions: False, WAL: True
Creating table: 2.3 ms
Inserting data: 14 ms
Updating data: 12.2 ms
Selecting data: 6.8 ms
Deleting data: 11.7 ms
Dropping table: 0 ms

Testing: Sqlite, transactions: True, WAL: False
Creating table: 13.5 ms
Inserting data: 20.3 ms
Updating data: 24.5 ms
Selecting data: 7.8 ms
Deleting data: 22.3 ms
Dropping table: 16.7 ms

Testing: Sqlite, transactions: True, WAL: True
Creating table: 3.2 ms
Inserting data: 5.8 ms
Updating data: 4.9 ms
Selecting data: 4.4 ms
Deleting data: 3.8 ms
Dropping table: 0 ms

Testing: Sqlce, transactions: False, WAL: False
Creating table: 2.8 ms
Inserting data: 24.4 ms
Updating data: 42.8 ms
Selecting data: 30.4 ms
Deleting data: 38.3 ms
Dropping table: 3.3 ms

Testing: Sqlce, transactions: True, WAL: False
Creating table: 2.1 ms
Inserting data: 24.6 ms
Updating data: 44.2 ms
Selecting data: 32 ms
Deleting data: 37.8 ms
Dropping table: 3.2 ms

~3 Sekunden für 200-inserts oder-updates mit sqlite könnte noch scheinen ein wenig hoch, aber es ist zumindest vernünftiger als 23 Sekunden. Umgekehrt könnte man besorgt sein, wie SqlCe nimmt sich zu wenig Zeit, um die gleiche 200-inserts oder Updates, vor allem, da es scheint keinen wirklichen Geschwindigkeitsunterschied zwischen jede SQL-Abfrage in einzelnen Transaktionen, oder zusammen in einer Transaktion. Ich weiß nicht genug über SqlCe, dies zu erklären, aber es macht mir sorgen. Würde es bedeuten, dass, wenn .Commit() zurückgibt, sind Sie nicht versichert, dass die änderungen tatsächlich auf den Datenträger geschrieben?

InformationsquelleAutor