MARS contre NextResult

Question

Je réhydrate mes objets métier en collectant des données à partir de plusieurs tables, par exemple,

SELECT \* FROM CaDataTable;
SELECT \* FROM NyDataTable;
SELECT \* FROM WaDataTable;

et ainsi de suite... (C# 3.5, SQL Server 2005)

J'ai utilisé des lots :

    void BatchReader()
    {
        string sql = "Select * From CaDataTable" +
                     "Select * From NyDataTable" +
                     "Select * From WaDataTable";

        string connectionString = GetConnectionString();
        using (SqlConnection conn = new SqlConnection(connectionString)) {
            conn.Open();
            SqlCommand cmd = new SqlCommand(sql, conn);
            using (SqlDataReader reader = cmd.ExecuteReader()) {
                do {
                    while (reader.Read()) {
                        ReadRecords(reader);
                    }
                } while (reader.NextResult());
            }
        }
    }

J'ai également utilisé plusieurs commandes sur la même connexion:

    void MultipleCommandReader()
    {
        string connectionString = GetConnectionString();
        string sql;
        SqlCommand cmd;
        using (SqlConnection conn = new SqlConnection(connectionString)) {
            conn.Open();  

            sql = "Select * From CaDataTable";
            cmd = new SqlCommand(sql, conn);
            using (SqlDataReader reader = cmd.ExecuteReader()) {
                while (reader.Read()) {
                    ReadRecords(reader);
                }
            }

            sql = "Select * From NyDataTable";
            cmd = new SqlCommand(sql, conn);
            using (SqlDataReader reader = cmd.ExecuteReader()) {
                while (reader.Read()) {
                    ReadRecords(reader);
                }
            }

            sql = "Select * From WaDataTable";
            cmd = new SqlCommand(sql, conn);
            using (SqlDataReader reader = cmd.ExecuteReader()) {
                while (reader.Read()) {
                    ReadRecords(reader);
                }
            }
        }
    }

L'une de ces techniques est-elle nettement meilleure que l'autre? De plus, y aurait-il un avantage si j'utilise MARS sur la deuxième méthode? En d'autres termes, est-ce aussi simple que de définir MultipleActiveResultSets=True dans la chaîne de connexion et de récolter un gros bénéfice?

Answer 1

Si la structure de données est la même dans chaque table, je ferais :

Sélectionner *, 'Ca' Source de CaDataTable
union all
Sélectionner *, 'Ny' Source de NyDataTable
union all
Sélectionner *, 'Wa' Source de WaDataTable

Answer 2

Sans réellement chronométrer les deux versions l'une contre l'autre, vous ne pouvez que spéculer....

Je parie que la version 1 (BatchReader) sera plus rapide, puisque vous n'avez qu'un seul aller-retour vers la base de données. La version 2 nécessite trois allers-retours distincts - un pour chaque requête que vous exécutez.

Mais encore une fois: vous ne pouvez vraiment le dire que si vous mesurez.

Marc

Oh, PS: bien sûr, dans un scénario réel, il serait également utile de limiter les colonnes retournées, par exemple ne pas utiliser SELECT * mais plutôt utiliser SELECT (liste de champs) et maintenir cette liste de champs aussi courte que possible.