Excel makró és SQL: Hogyan kérdezd le egy SQL lekérdezés visszakapott sorainak pontos számát?

Az üzleti döntések sokszor az adatok pontos ismeretén alapulnak. Amikor Excelben dolgozunk SQL adatbázisokkal, és makrókkal automatizáljuk a folyamatokat, gyakran felmerül a kérdés: pontosan hány sort is kaptunk vissza a komplex lekérdezés eredményeként? Ez nem pusztán egy számszerű adat; ez lehet a siker vagy a kudarc mérőszáma, a hibakeresés kiindulópontja, vagy épp a felhasználói élmény egyik alappillére. 📊 Cikkünkben bemutatjuk, hogyan kérdezhetjük le egy SQL lekérdezés visszakapott sorainak pontos számát Excel makró és VBA segítségével, részletesen kitérve a különböző módszerekre, előnyeikre és hátrányaikra.

### Miért annyira fontos a pontos sorszám?

Gondoljunk csak bele: egy riport generálásakor látjuk, hogy 1000 sornyi adatot kellett volna lekérdezni, de az Excel táblázatunkban csak 950 sor jelenik meg. Hol van a maradék 50? Hiba történt a lekérdezésben? Esetleg a makró állt le idő előtt? A pontos sorszám ismerete alapvető fontosságú a következő okok miatt:

* **Adatvalidálás és integritás:** Meggyőződhetünk arról, hogy minden várt adat megérkezett-e. Ha az elvárt sorok száma eltér a ténylegesen beolvasottól, azonnal cselekedhetünk.
* **Teljesítmény monitoring:** Képet kaphatunk arról, hogy mekkora adatmennyiséggel dolgozunk. Ez segíthet a makrók optimalizálásában, vagy a lekérdezések finomhangolásában.
* **Felhasználói visszajelzés:** Egy felhasználó sokkal magabiztosabb lesz, ha látja, hogy „X” darab rekord került betöltésre, mint ha csak egy üres vagy részleges táblázatot látna. Ez növeli az alkalmazásunkba vetett bizalmat.
* **Hibakeresés:** Ha valami nem működik, az első lépések egyike a visszakapott sorok számának ellenőrzése. Ez a szám sokat elárulhat a probléma gyökeréről.

Láthatjuk, hogy nem egyszerűen egy technikai részletről van szó, hanem egy alapvető fontosságú információról, ami az automatizálás és az adatkezelés megbízhatóságát szolgálja.

### A SQL oldalról: Hány sorom van valójában?

Mielőtt belevetnénk magunkat az Excel VBA rejtelmeibe, érdemes megvizsgálni, hogyan közelíthetjük meg a sorszámlálás problémáját magában az SQL-ben. A legtöbb adatbázis-kezelő rendszer kínál erre beépített funkciókat.

#### 1. A klasszikus `SELECT COUNT(*)`

A legközvetlenebb és leguniverzálisabb módja a sorok számának meghatározására egy különálló `SELECT COUNT(*)` lekérdezés futtatása.
„`sql
SELECT COUNT(*) FROM YourTable WHERE YourCondition;
„`
Ez a lekérdezés egyetlen számot ad vissza, ami a feltételeknek megfelelő sorok számát jelenti.
**Előnyei:** Rendkívül pontos, és minden SQL adatbázisban működik.
**Hátrányai:** Két különálló lekérdezést kell futtatni: egyet a sorok számának lekérdezésére, egyet pedig maguknak az adatoknak a lekérésére. Ez némi extra terhelést jelenthet az adatbázis számára.

#### 2. Az `@@ROWCOUNT` (SQL Server specifikus)

SQL Server környezetben van egy nagyon hasznos beépített függvény, az `@@ROWCOUNT`. Ez a függvény visszaadja az *előző* T-SQL utasítás által érintett vagy visszaadott sorok számát.
„`sql
SELECT Column1, Column2 FROM YourTable WHERE YourCondition;
SELECT @@ROWCOUNT AS NumberOfRows;
„`
Itt a `SELECT` utasítás után azonnal futtatjuk a `SELECT @@ROWCOUNT` utasítást. Az adatbázis ekkor két eredményhalmazt küld vissza: az elsőt az adatokkal, a másodikat pedig a sorok számával.
**Előnyei:** Nagyon hatékony, mert nem kell duplán lekérdezni az adatbázist. Egyetlen utasításkötegen belül is megoldható.
**Hátrányai:** Kizárólag SQL Serveren működik. Más adatbázisoknak (pl. MySQL `ROW_COUNT()`, Oracle `SQL%ROWCOUNT` PL/SQL-ben) megvannak a saját, hasonló funkciói, de nem pontosan ugyanígy használhatók.

### Az Excel VBA és ADO varázslata: Híd az adatokhoz

Ahhoz, hogy az Excel makró képes legyen kommunikálni egy SQL adatbázissal, az ActiveX Data Objects (ADO) könyvtárat kell használnunk. Először is, győződjünk meg róla, hogy a VBA projektünkben be van kapcsolva a „Microsoft ActiveX Data Objects x.x Library” referencia (Tools -> References menüpont alatt). Ez létfontosságú a `Connection` és `Recordset` objektumok használatához.

A kapcsolódás és a lekérdezés alapvető lépései a következők:
1. **Kapcsolat létrehozása:** Létrehozzuk az `ADODB.Connection` objektumot.
2. **Kapcsolati sztring megadása:** Ezzel mondjuk meg az Excelnek, melyik adatbázishoz, milyen hitelesítéssel kapcsolódjon.
3. **Lekérdezés futtatása:** `ADODB.Recordset` vagy `ADODB.Command` objektummal futtatjuk az SQL lekérdezést.
4. **Adatok feldolgozása:** A `Recordset` objektum tartalmazza a visszaadott adatokat, amiket aztán az Excel munkalapra másolhatunk.

### A „mennyi is az annyi” kérdés VBA-ból – Különféle megközelítések

Most pedig lássuk, hogyan kérdezhetjük le konkrétan a sorok számát a VBA-ban, különböző stratégiákat alkalmazva.

#### 1. A `Recordset.RecordCount` tulajdonság használata

Ez az első, ami eszünkbe juthat, és első ránézésre a legegyszerűbbnek tűnik. Miután futtattunk egy `SELECT` lekérdezést, a `Recordset` objektum rendelkezik egy `RecordCount` tulajdonsággal, ami elvileg visszaadja a sorok számát.
„`vba
Dim cn As ADODB.Connection
Dim rs As ADODB.Recordset
Dim sql As String
Dim rowCount As Long

Set cn = New ADODB.Connection
cn.ConnectionString = „Provider=SQLOLEDB;Data Source=YourServer;Initial Catalog=YourDB;Integrated Security=SSPI;”
cn.Open

sql = „SELECT Column1, Column2 FROM YourTable WHERE YourCondition;”
Set rs = New ADODB.Recordset

‘ LÉNYEGES! Állítsuk be a kurzor típusát, különben -1-et kaphatunk!
rs.Open sql, cn, adOpenStatic, adLockReadOnly

If Not rs.EOF Then ‘ Ellenőrizzük, van-e egyáltalán adat
‘ Ahhoz, hogy a RecordCount pontos legyen, át kell menni a Recordset végére
‘ Ezt a MoveLast metódus teszi meg
rs.MoveLast
rs.MoveFirst ‘ Majd vissza az elejére, ha feldolgozni is akarjuk
rowCount = rs.RecordCount
MsgBox „A lekérdezés ” & rowCount & ” sort adott vissza (RecordCount).”, vbInformation
Else
rowCount = 0
MsgBox „A lekérdezés 0 sort adott vissza.”, vbInformation
End If

‘ Adatok másolása Excelbe (pl. Cells(2, 1).CopyFromRecordset rs)
‘ …

rs.Close
Set rs = Nothing
cn.Close
Set cn = Nothing
„`
⚠️ **Fontos figyelmeztetés:** A `Recordset.RecordCount` értéke nem mindig megbízható azonnal! Sok esetben (különösen alapértelmezett, `adForwardOnly` kurzor típus esetén) `-1`-et ad vissza, ami azt jelenti, hogy a sorok számát nem lehet megállapítani, amíg az összes adatot le nem olvasták. Ahhoz, hogy pontos értéket kapjunk, vagy statikus kurzort (`adOpenStatic`) kell használnunk, vagy miután a `Recordset` megnyílt, el kell mozdulnunk a `Recordset` végére a `rs.MoveLast` metódussal, mielőtt a `RecordCount` tulajdonságot lekérdeznénk. Ne feledjük, a `MoveLast` egy nagy `Recordset` esetén lassú lehet, mert az adatbázisnak az összes sort le kell töltenie a kliensre! Utána pedig célszerű `rs.MoveFirst`-tel visszamenni az első rekordra, ha fel is akarjuk dolgozni az adatokat.

#### 2. A különálló `SELECT COUNT(*)` lekérdezés használata

Ez a módszer sokszor a legrobosztusabb és legmegbízhatóbb. Először egy külön lekérdezéssel kérjük le a sorok számát, majd egy másik lekérdezéssel az adatokat.
„`vba
Dim cn As ADODB.Connection
Dim rsData As ADODB.Recordset
Dim rsCount As ADODB.Recordset
Dim sqlData As String
Dim sqlCount As String
Dim rowCount As Long

Set cn = New ADODB.Connection
cn.ConnectionString = „Provider=SQLOLEDB;Data Source=YourServer;Initial Catalog=YourDB;Integrated Security=SSPI;”
cn.Open

sqlCount = „SELECT COUNT(*) FROM YourTable WHERE YourCondition;”
Set rsCount = New ADODB.Recordset
rsCount.Open sqlCount, cn, adOpenForwardOnly, adLockReadOnly

If Not rsCount.EOF Then
rowCount = rsCount.Fields(0).Value ‘ Az első oszlop tartalmazza a COUNT(*) értékét
MsgBox „A lekérdezés ” & rowCount & ” sort fog visszaadni (külön COUNT).”, vbInformation
Else
rowCount = 0
MsgBox „A COUNT lekérdezés 0 sort adott vissza.”, vbInformation
End If
rsCount.Close
Set rsCount = Nothing

If rowCount > 0 Then ‘ Csak akkor kérjük le az adatokat, ha van mit
sqlData = „SELECT Column1, Column2 FROM YourTable WHERE YourCondition;”
Set rsData = New ADODB.Recordset
rsData.Open sqlData, cn, adOpenForwardOnly, adLockReadOnly

‘ Adatok másolása Excelbe
If Not rsData.EOF Then
‘ Példa: Másolás A2-es cellától
Sheets(„Sheet1”).Cells(2, 1).CopyFromRecordset rsData
End If
rsData.Close
Set rsData = Nothing
End If

cn.Close
Set cn = Nothing
„`
**Előnye:** Nagyon megbízható, és a `COUNT(*)` lekérdezés általában gyors, még nagy táblákon is, ha megfelelő indexek vannak. Nem kell az összes adatot letölteni, mielőtt tudnánk a számot.
**Hátránya:** Két hálózati oda-vissza út az adatbázishoz, ami lassabb lehet, mint egyetlen lekérdezés, ha az adatbázis és a kliens közötti késleltetés (latency) magas.

#### 3. Tárolt eljárások és több eredményhalmaz kezelése

Ez a legfejlettebb, de sokszor a leghatékonyabb módszer, különösen SQL Server környezetben. Létrehozhatunk egy tárolt eljárást, ami egyszerre adja vissza az adatokat és a sorok számát is, akár egy másik eredményhalmazban, akár kimeneti paraméterként.
Nézzünk egy példát, ahol a tárolt eljárás két eredményhalmazt ad vissza: az elsőt az adatokkal, a másodikat a `@@ROWCOUNT` értékével.

**SQL Tárolt eljárás (példa SQL Serverre):**
„`sql
CREATE PROCEDURE GetRelevantDataWithCount
@ConditionValue VARCHAR(50)
AS
BEGIN
SELECT Column1, Column2, Column3
FROM YourTable
WHERE SomeColumn = @ConditionValue;

SELECT @@ROWCOUNT AS NumberOfRows; — Visszaadja az előző SELECT által érintett sorok számát
END;
„`

**VBA kód a tárolt eljárás hívására:**
„`vba
Dim cn As ADODB.Connection
Dim rs As ADODB.Recordset
Dim cmd As ADODB.Command
Dim rowCount As Long
Dim param As ADODB.Parameter

Set cn = New ADODB.Connection
cn.ConnectionString = „Provider=SQLOLEDB;Data Source=YourServer;Initial Catalog=YourDB;Integrated Security=SSPI;”
cn.Open

Set cmd = New ADODB.Command
Set cmd.ActiveConnection = cn
cmd.CommandType = adCmdStoredProc
cmd.CommandText = „GetRelevantDataWithCount”

‘ Paraméter hozzáadása, ha van
Set param = cmd.CreateParameter(„@ConditionValue”, adVarChar, adParamInput, 50, „SomeValue”)
cmd.Parameters.Append param

‘ A tárolt eljárás végrehajtása
Set rs = cmd.Execute

‘ Első eredményhalmaz: az adatok
If Not rs.EOF Then
Sheets(„Sheet1”).Cells(2, 1).CopyFromRecordset rs
‘ MsgBox „Adatok betöltve az első eredményhalmazból.”, vbInformation
End If

‘ Átlépés a következő eredményhalmazra
Set rs = rs.NextRecordset

‘ Második eredményhalmaz: a sorok száma
If Not rs.EOF Then
rowCount = rs.Fields(„NumberOfRows”).Value
MsgBox „A lekérdezés ” & rowCount & ” sort adott vissza (tárolt eljárás).”, vbInformation
Else
rowCount = 0
MsgBox „A lekérdezés 0 sort adott vissza.”, vbInformation
End If

rs.Close
Set rs = Nothing
Set cmd = Nothing
cn.Close
Set cn = Nothing
„`
**Előnyei:** Ez a módszer rendkívül hatékony, mivel egyetlen hívással (és egyetlen oda-vissza úttal) kapjuk meg az adatokat és a sorok számát is. Biztonságosabb (a paraméterezés miatt), és a logikát az adatbázison tarthatjuk, ami jobb teljesítményt és karbantarthatóságot eredményezhet.
**Hátrányai:** Komplexebb beállítás szükséges (tárolt eljárás létrehozása és karbantartása az adatbázisban), és adatbázis-specifikus megoldás.

### Gyakorlati tippek és a legjobb gyakorlatok

* **Mindig használjunk hibakezelést:** A VBA-ban az `On Error GoTo ErrorHandler` nélkülözhetetlen, amikor adatbázissal kommunikálunk. A hálózati problémák, jogosultsági gondok vagy SQL hibák könnyen leállíthatják a makrót.
* **Optimalizáljuk a lekérdezéseket:** Bármelyik módszert is választjuk, a mögöttes SQL lekérdezésnek gyorsnak és hatékonynak kell lennie. Használjunk indexeket, kerüljük a `SELECT *` használatát, és csak a szükséges oszlopokat kérjük le.
* **Adatbázis-specifikus szempontok:** Míg a `SELECT COUNT(*)` univerzális, az `@@ROWCOUNT` és a tárolt eljárások implementálása adatbázis-kezelő rendszertől függően változhat. Mindig ellenőrizzük az adott adatbázis dokumentációját.
* **Bezárás és felszabadítás:** Mindig zárjuk be az `ADODB.Recordset` és `ADODB.Connection` objektumokat a `.Close` metódussal, és állítsuk `Nothing`-ra a változókat. Ez felszabadítja a memóriát és az adatbázis-kapcsolatokat.

> **Személyes véleményem és a valós tapasztalatok alapján:** Bár a `Recordset.RecordCount` elsőre csábítónak tűnik a látszólagos egyszerűsége miatt, az évek során többször is meggyőzött arról, hogy a legmegbízhatóbb módszer a `SELECT COUNT(*)` külön lekérdezésként történő futtatása. Különösen olyan környezetekben, ahol a hálózati kapcsolat nem mindig stabil, vagy ahol a felhasználók eltérő ADO verziókkal dolgoznak, a `RecordCount` gyakran váratlanul „-1”-et adott vissza, míg a `SELECT COUNT(*)` mindig pontos és konzisztens eredményt szolgáltatott. Ezen felül, a `MoveLast` használata jelentős teljesítménycsökkenést okozhat nagy adathalmazoknál, ami rontja a felhasználói élményt. Ha pedig az alkalmazás komplexitása indokolja, egy jól megírt tárolt eljárás, ami több eredményhalmazt is visszaad, a leghatékonyabb és legtisztább megoldás lehet. A megbízhatóság és a precizitás az automatizált folyamatokban a legfontosabb, és ezért érdemes a robusztusabb megoldásokat előnyben részesíteni.

### Összefoglalás

Az Excel makró és az SQL adatbázisok közötti interakció során a visszakapott sorok számának pontos meghatározása kritikus fontosságú. Láthattuk, hogy több megközelítés is létezik:
* A `Recordset.RecordCount` tulajdonság, ami odafigyelést igényel a kurzor típusával és a `MoveLast` használatával.
* A különálló `SELECT COUNT(*)` lekérdezés, mint a legmegbízhatóbb és legáltalánosabb megoldás.
* A tárolt eljárások, melyek több eredményhalmazt is visszaadhatnak, a legfejlettebb és leghatékonyabb megközelítést kínálva.

A választás mindig az adott helyzet, az adatbázis típusa, a teljesítményigény és a fejlesztői preferenciák függvénye. Azonban bármelyik módszert is választjuk, a cél mindig ugyanaz: pontos, megbízható és felhasználóbarát adatfeldolgozást biztosítani az Excel és SQL közötti szinergiában. Ne feledjük, az adatok ereje a pontos ismeretükben rejlik! 🚀