Az ActiveRecord lekérdezi és Ön: hogyan lehet megtalálni () a feladathoz megfelelő módszert

Fotó: Agence Olloweb az Unsplash-en

Ha bármi olyan vagy, mint én, akkor az a tapasztalata, amikor új programozóként ismerte meg az adatbázisokat, félelmetes tapasztalat volt. Hirtelen az internet bonyolult belső működése világossá vált Ön előtt - táblázatok és társulások egészen lefelé.

Ha Ön is valami olyan, mint én, amikor az SQL elsajátítását és az adatbázisokkal való való interakciót illeti, akkor az első tapasztalataid valószínűleg egy kissé durva ébresztési hívást jelentenek a korábban kiváltott álmában. Hirtelen rájössz, hogy minden olyan hatalmas információt tároló adatbázishoz, ahol tud valaki megtudni, hogyan kell megrontani az irgalmas dolgot, hogy az információt kinyerje. És valószínűleg rájöttél, hogy valaki előbb vagy utóbb te leszel.

Szerencsére a modern programozási keretrendszer kényelmes és intuitív módszereket adott nekünk az adatok létrehozására, tárolására és visszakeresésére. Ma egy konkrét keretről - a Ruby on Rails-ről - és annak egy olyan aspektusáról beszélünk, amely megkönnyíti az adatbázis-kezelést - az ActiveRecord.

A Rails és az ActiveRecord jól dokumentálva vannak az interneten, ezért mélyebb elemzést hagyok mások, okosabb emberek számára. Ma különösen egy olyan szempontot fogok megérinteni, amely megragadott engem, amikor először megtanultam a keretet, hogy más hallgatók elkerüljék ugyanazon buktatókat: adatbázis-lekérdezések.

A Rails alkalmazáson belül a modellek, a vezérlők és a nézetek mind egyesítik erőit, hogy kitűnő munkát végezzenek az adatbázisba történő mentés során, de végül vissza kell húznia ezeket az információpéldányokat, hogy logikát tegyen rájuk, vagy egyszerűen csak megmutatni nekik. Ekkor lépnek fel a lekérdezések. Az ActiveRecordon belüli lekérdezések alapvetően SQL-parancsok, amelyek egy olvasható, írható Ruby-szintaxis meleg takarójába vannak csomagolva, lehetővé téve, hogy jobban gondolkodjon azon, hogy mit fog csinálni ezekkel az adatokkal, ahelyett, hogy elsősorban arra törekszik, hogy hogyan tudja letölteni.

Nagyon sok speciális lekérdezési módszer létezik minden célra, és mindazt elolvashatja a Rails hivatalos dokumentációjában, de ma megérintem a három leggyakoribb és a közöttük levő különbségeket, valamint egy néhány hasonló kapcsolódó módszer kontextusos példaképp:

  1. .megtalálja()
  2. .find_by ()
  3. .ahol()

.megtalálja()

A find () talán a legegyszerűbb lekérdezési módszer, mindazonáltal a leghatékonyabb. Ez lehetővé teszi, hogy egyetlen objektumot lehívjon az adatbázisból az elsődleges kulcs (ID) vonatkozásában, amelyet argumentumként ad meg. Tegyük fel, hogy létrehozott egy osztályt, amely egy vendég képvisel egy késő esti beszélgetési show-t:

Mivel a vendég minden példányát létrehozásuk után menti, az elsődleges kulcsot vagy azonosítót kap az adatbázisban. Annak érdekében, hogy a jövőben visszanyerje ezt a vendégpéldányt, akkor egyszerűen kitölti a find () parancsot a Vendég osztályban (így például egy változóba mentve):

Amely visszaadja a vendég osztály példányát, amikor felszólítják:

A fenti find () módszer motorháztetője alatt futó SQL egyenérték:

Úgy tűnhet, hogy a find () túl specifikus módszer - elvégre, hányszor fogja pontosan tudni, hogy mi az adatbázisában lévő objektumpéldány azonosítója? Meglepő módon az ID-khez gyakrabban férhet hozzá, mint gondolnád, különösen akkor, ha HTTP paramétereket használ a Rails-ben. De ennek ellenére nagyon konkrét célt szolgál.

Érdemes megjegyezni, hogy több példányt is visszatérhet, ha elsődleges kulcsok tömbjét adja be argumentumként:

A következők segítségével valami hasonlót hajthat végre:

.vesz

amely argumentumként számot kap és az osztály sok példányát növekvő sorrendben veszi le.

Hasonló lelet-hajtások () a következők:

.első és utolsó

amely az osztály legkorábbi és legújabb létrehozott példányait veszi be. Ezeket számokat is lehet argumentumként megadni, visszaadva az osztály sok példányát növekvő vagy csökkenő sorrendben.

Ez vezet a következő és sokoldalúbb lekérdezési módszerünkhöz: find_by ()

.find_by ()

Első pillantásra a .find_by () ismerősnek tűnhet, de az ismeretek gyorsan véget érnek. Mint a .find (), .find_by () implicit módon csak az osztály egyetlen objektumát adja vissza, de megkülönbözteti magát azáltal, hogy engedélyezi az elsődleges kulcson kívüli egyéb attribútumok keresését, és egynél több attribútum keresését is lehetővé teszi. Például érdemes egy vendég nevét keresni a nevük keresésével:

Az egyenértékű SQL itt:

Nagyszerű, visszatértünk egy tárgyhoz! De várjunk, itt Michael J. Fox a színész, és meg akartuk találni Michael J. Fox űrhajósot! (Megjegyzés: ez csak egy példa, nem tudom sem megerősíteni, sem tagadni a Michael J. Fox nevű űrhajós létezését.)

Annak érdekében, hogy megtaláljuk ezt a példát, részletesebben meghatározhatjuk:

Hurrá! Köszönhetően annak, hogy finomítani tudjuk a keresést, megjelenítettük a Guest osztály helyes példányát. Ez a .find_by () ereje. Elméletileg annyi osztályattribútumot kereshet, amennyit csak akart, hogy szűkítse a keresést.

A .find_by () segítségével speciális asztalos osztályokat is megtalálhat alkalmazásaiban, ami nagyon sokoldalú eszköz az osztály módszerek létrehozásához. Tegyük fel, hogy egy vendég megjelent egy beszélgetési show egy adott epizódjában, és meg akarta találni az ezzel a megjelenéssel kapcsolatos információkat. Ha megjelenési osztályunk létezik:

A .find_by () segítségével könnyen megkeresheti a Megjelenés adott példányát, és illesztheti be ezt a logikát bárhol. Használjuk osztálymódszerként a vendég számára:

Ha egy vendég példányánál használják, és amikor egy epizód példányát adják argumentumként, akkor az visszatér egy adott megjelenés példányához. Elképesztő!

Lehet, hogy azt mondod: „Mi lenne, ha szeretném lekérni az osztály több példányát? Mi lenne, ha szeretném megszerezni mind a Michael J. Fox színész, mind a Michael J. Fox űrhajós minden példányát? "

Örülök, hogy megkérdezted, mert itt játszik szerepet a következő és az utolsó módszerünk: .where ()

.ahol()

A három fő lekérdezési módszer közül, amelyekkel megbeszéljük ebben a bejegyzésben, a .where () valószínűleg a sokoldalúbb, de a legösszetettebb és a legkönnyebben összetéveszthető.

Míg a .find () és .find_by () visszaad egy objektum egyes példányait, a .where () visszaadja az úgynevezett “ActiveRecord :: Relation object” -et, lényegében példányok tömbjének néhány extra információval. Ennek eredményeként a .where () teljes körű felhasználása további beavatkozási ismereteket igényel a beágyazott információk tömbjeivel való munka során.

A .where () -et „feltétel” módszernek kell tekinteni, más néven olyannak, amely lehetővé teszi, hogy ellenőrizze, hogy mely objektumokat küldik vissza, azáltal, hogy meghatározza, hogy mely „feltételeket” használja az adatbázisba, és korlátozza a visszatérő értékeket. Ismételten arra bátorítom, hogy olvassa el a fejlettebb témákra vonatkozó Rails dokumentációt a Feltételekről, de megismerem azokat az alapvető használati eseteket, amelyekre valószínűleg szüksége lesz.

A korábban bemutatott példákhoz hasonlóan ki lehet írni egy .where () kérés szintaxisát, hogy MINDEN példányt találjon a vendégekről, Michael Michael Fox nevű vendégként:

Hú, most van még több! Van Michael J. Fox a festő, és Michael J. Fox a zenész is. Egy egyszerű módszerrel minden vendég számára tömböt kaptunk azzal a névvel - milyen erős eszköz!

Itt a dolgok érdekessé válnak. Ha több feltételt kíván átadni egy .where () lekérdezésnek, akkor a szintaxis kevésbé ismerősre változik.

Ha a Michael J. Fox nevű szereplőknek több példánya volt, akkor a lekérdezést a .find_by () kéréshez hasonlóan is megfogalmazhatja:

Vagy megfogalmazhatja az SQL-hez hasonlóan, például:

Ez a megfogalmazás a legtöbb esetben előnyben részesített, mivel az érvek közvetett átvitele a? S-ken nagyobb biztonságot biztosít a paraméterekben, és védelmet nyújt a rosszindulatú kódok befecskendezése ellen. Nem valami miatt kell aggódni a denevér után a tanulás során, hanem fontos szem előtt tartani.

Ha szeretné lekérni Michael J. Fox színész vagy OR űrhajós példányait, akkor összekapcsolhatja a .where () kéréseit egy összetettebb lekérdezés létrehozása céljából:

A hasonló kérések együttes láncolása az .or használatával, valamint az implicit és a fentiekben említett keresési képesség révén a .where () eszköz hatékony segédprogramot jelent az adatbázis átfésültetéséhez és az osztályok több példányának pontos visszatéréséhez, ahogyan szüksége van rájuk. .

Most, hogy megismertük a Rails és az ActiveRecord mindhárom legszélesebb körű lekérdezési módszerét, a következő lépés a gyakorlat és a saját alkalmazásokban való felhasználása! A Rails dokumentációra való hivatkozás továbbra is útmutatást nyújt és további áttekintést nyújt az utazásról. Sok szerencsét!