A Laravel számos hasznos eszközt kínál az adatbázis-alkalmazások teszteléséhez. Először is használhatja a PHP helper módszert seeInDatabase() annak ellenőrzésére, hogy az adatbázisban lévő adatok megfelelnek-e egy bizonyos kritériumrendszernek. Például, ha azt szeretné ellenőrizni, hogy a felhasználók táblában van-e egy rekord, amelynek e-mail mezője egyenlő: [e-mail védett], a következőket teheti:
PHP
{
// Alkalmazási hívás kezdeményezése...
$this -> seeInDatabase("users" , [
"e-mail" => " [e-mail védett]"
]);
}
Természetesen olyan módszereket, mint a PHP seeInDatabase() a kényelem érdekében készült. A PHPUnit bármely beépített érvényesítési módszerét használhatja a tesztek kiegészítésére.
Az adatbázis alaphelyzetbe állítása minden teszt után
Gyakran hasznos az adatbázis alaphelyzetbe állítása minden teszt után, hogy az előző teszt adatai ne befolyásolják a következő teszteket.
Migrációk használata
Az adatbázis állapotának visszaállításának egyik módja az adatbázis visszaállítása minden teszt után, és áttelepítés a következő teszt előtt. A Laravel egy egyszerű DatabaseMigrations tulajdonságot biztosít, amely ezt automatikusan elvégzi Ön helyett. Csak használja ezt a tulajdonságot a tesztórán, és mindent megtesznek helyetted:
PHP /**
{
a DatabaseMigrations használata;
*
* @return érvénytelen
*/
{
$this -> látogatás ("/" )
-> lásd ("Laravel 5" );
}
}
Tranzakciók használata
A DB állapot visszaállításának másik módja az, hogy minden tesztesetet egy DB tranzakcióba csomagol. Ehhez a Laravel egy praktikus DatabaseTransactions szolgáltatást is biztosít, amely automatikusan elvégzi ezt Ön helyett:
PHP Az Illuminate\Foundation\Testing\WithoutMiddleware használata; osztály Az ExampleTest kiterjeszti a TestCase-t /**
használja az Illuminate\Foundation\Testing\DatabaseMigrations;
használja az Illuminate\Foundation\Testing\DatabaseTransactions;
{
használja a DatabaseTransactions szolgáltatást;
* Példa egy alapvető funkcionális tesztre.
*
* @return érvénytelen
*/
{
$this -> látogatás ("/" )
-> lásd ("Laravel 5" );
}
}
Alapértelmezés szerint ez a tulajdonság csak az alapértelmezett adatbázis-kapcsolatot fogja becsomagolni egy tranzakcióba. Ha az alkalmazás több adatbázis-kapcsolatot használ, meg kell határoznia a PHP tulajdonságot $connectionsToTransact tesztóráján. Ennek a tulajdonságnak kapcsolatnevek tömbjének kell lennie a tranzakciók végrehajtásához.
Gyárak létrehozása
Teszteléskor előfordulhat, hogy a teszt futtatása előtt több rekordot kell beszúrnia a DB-be. Az adatok létrehozásakor az egyes oszlopok értékeinek manuális megadása helyett a Laravel lehetővé teszi, hogy szabványos attribútumkészletet határozzon meg minden egyes Eloquent modellhez a gyárak használatával. Először nézze meg az adatbázis/factories/ModelFactory.php fájlt az alkalmazásban. Kezdetben ez a fájl egy gyár definícióját tartalmazza:
PHP $factory -> define (App \ User ::class, function (Faker \ Generator $faker ) (
statikus $jelszó ;
Visszatérés[
"name" => $faker -> név ,
"email" => $faker -> egyedi()-> safeEmail ,
"password" => $password ?: $password = bcrypt ("titkos") ,
"remember_token" => str_random (10),
];
});
A gyári definícióként szolgáló lezárásban visszaadhatja a szabványos tesztértékeket az összes modellattribútumhoz. A lezárás megkapja a Faker PHP könyvtár egy példányát, amely lehetővé teszi, hogy kényelmesen generáljon különféle véletlenszerű adatokat teszteléshez.
Természetesen hozzáadhatja saját további gyárait a ModelFactory.php fájlban. Minden modellhez további gyári fájlokat is létrehozhat az áttekinthetőbb rendszerezés érdekében. Például létrehozhat UserFactory.php és CommentFactory.php fájlokat az adatbázisban/gyárak mappában. A Laravel automatikusan letölti a gyári mappában lévő összes fájlt.
A gyári állapotok
Az állapotok lehetővé teszik egyedi változtatások meghatározását, amelyek bármilyen kombinációban alkalmazhatók a modellgyárakra. Előfordulhat például, hogy a felhasználói modell hibás állapota megváltoztatja az egyik attribútum alapértelmezett értékét. Az állapottranszformációkat a PHP metódussal határozhatja meg állapot() :
PHP $gyári -> állapot (App \ User ::class, "delinquent" , function ($faker ) (
Visszatérés [
"account_status" => "delikvens" ,
];
});
A gyárak használata
Modellek készítése
A gyárak meghatározása után használhatja a PHP globális függvényét gyár() tesztjeiben vagy kezdőfájljaiban modellpéldányok generálásához. Nézzünk tehát néhány példát a modellek létrehozására. Először a PHP módszert használjuk gyártmány() modellek létrehozásához, de nem menti őket az adatbázisba:
PHP nyilvános függvény testDatabase()
{
$user = gyári (App\User::class)->make();
Létrehozhat modellgyűjteményt vagy egy adott típusú modellt is:
PHP $users = gyári (App\User::class, 3)->make();
Bármelyiket alkalmazhatja a modellekre is. Ha több állapotmódosítást szeretne alkalmazni a modellekre, meg kell adnia az egyes állapotok nevét:
PHP $users = gyári (App \ User ::class, 5 )-> states ( "delinquent" ) -> make ();
$users = gyári (App \ User ::class, 5 ) -> állapotok ( "prémium" , "delikvens" ) -> make ();
Attribútum felülírása
Ha felül akarja írni a modellek egyes alapértelmezett értékeit, átadhat egy értéktömböt a PHP metódusnak. gyártmány(). Csak a megadott értékek kerülnek cserére, a többi a gyárilag megadott értékek szerint lesz beállítva:
PHP $user = gyári (App\User::class)->make ([
"name" => "Abigail" ,
]);
Állandó modellek
PHP módszer teremt() nem csak modellpéldányokat hoz létre, hanem az Eloquent PHP metódussal az adatbázisban is tárolja megment() :
PHP nyilvános függvény testDatabase()
{
// Az App\User egy példányának létrehozása...
$user = gyári (App\User::class)->create();
// Hozzon létre három példányt az App\User...
$users = gyári (App\User::class, 3)->create();
// A modell használata a tesztekben...
}
A modell attribútumait felülírhatja, ha egy tömböt ad át egy PHP metódusnak teremt():PHP gyártmány());
});
Bezárási kapcsolatok és attribútumok
A modellekhez kapcsolatokat is csatolhat a gyári definíciókban szereplő záróattribútumok használatával. Ha például egy bejegyzés létrehozásakor a Felhasználói modell új példányát szeretné létrehozni, akkor ezt tegye:
PHP $gyári ->
Visszatérés [
"title" => $faker -> title ,
"content" => $faker -> bekezdés ,
"user_id" => function() (
vissza a gyárat (App\User::class)->create()->id;
}
];
});
Ez a lezárás egy speciális attribútumtömböt is kap a gyártól, amely tartalmazza:
PHP $factory -> define (App \ Post ::class, function ($faker ) (
Visszatérés [
"title" => $faker -> title ,
"content" => $faker -> bekezdés ,
"user_id" => function() (
vissza a gyárat (App\User::class)->create()->id;
},
"user_type" => függvény ($post tömb) (
return App\User::find($post["felhasználói_azonosító"])->típus;
}
];
});
: Az adatbázisok tesztelése és hibakeresése
Az alkalmazáskód automatikus egységtesztelése egyszerű és egyértelmű. Hogyan lehet tesztelni egy adatbázist? Vagy egy adatbázissal működő alkalmazás. Hiszen az adatbázis nem csak programkód, az adatbázis egy objektum, amely elmenti az állapotát. És ha a tesztelés során elkezdjük az adatbázisban lévő adatokat módosítani (és e nélkül milyen tesztelésünk lesz?!), akkor minden teszt után megváltozik az adatbázis. Ez megzavarhatja a további teszteket, és véglegesen megsértheti az adatbázist.
A probléma megoldásának kulcsa a tranzakciók. Ennek a mechanizmusnak az egyik jellemzője, hogy mindaddig, amíg a tranzakció nem fejeződött be, bármikor visszavonhatja az összes módosítást, és visszaállíthatja az adatbázist a tranzakció kezdetekor érvényes állapotba.
Az algoritmus a következő:
- tranzakció megnyitása;
- szükség esetén elvégzjük a tesztelés előkészítő lépéseit;
- végezzünk egységtesztet (vagy egyszerűen futtassuk le azt a szkriptet, amelynek működését ellenőrizni szeretnénk);
- ellenőrizze a szkript eredményét;
- Töröljük a tranzakciót, visszaállítjuk az adatbázist az eredeti állapotába.
Még ha a tesztelés alatt álló kódban vannak lezáratlan tranzakciók is, a külső ROLLBACK továbbra is megfelelően visszaállítja az összes módosítást.
Jó, ha SQL szkriptet vagy tárolt eljárást kell tesztelnünk. Mi van akkor, ha egy olyan alkalmazást tesztelünk, amely maga is csatlakozik az adatbázishoz, és új kapcsolatot nyit meg? Ezen túlmenően, ha hibakeresést végzünk, akkor valószínűleg a hibakeresés alatt álló alkalmazás szemével szeretnénk az adatbázist nézni. Mi a teendő ebben az esetben?
Ne rohanjon elosztott tranzakciók létrehozásával, van egyszerűbb megoldás is! Szabványos SQL-kiszolgálóeszközökkel megnyithat egy tranzakciót az egyik kapcsolaton, és folytathatja azt egy másikon.
Ehhez csatlakoznia kell a szerverhez, meg kell nyitnia egy tranzakciót, be kell szereznie egy tokent az adott tranzakcióhoz, majd át kell adnia ezt a tokent a tesztelés alatt álló alkalmazásnak. A munkamenetében csatlakozik a tranzakciónkhoz, és ettől a pillanattól kezdve a hibakeresési munkamenetünkben pontosan úgy fogjuk látni az adatokat (és érezni a zárakat is), ahogy a tesztelt alkalmazás látja.
A műveletek sorrendje a következő:
Miután elindítottunk egy tranzakciót egy hibakeresési munkamenetben, meg kell találnunk az azonosítóját. Ez egy egyedi karakterlánc, amely alapján a szerver megkülönbözteti a tranzakciókat. Ezt az azonosítót valahogy át kell adni a tesztelt alkalmazásnak.
Most az alkalmazás feladata, hogy kapcsolódjon a kontrolltranzakciónkhoz, mielőtt elkezdené azt tenni, amit tennie kell.
Ezután az alkalmazás elkezd dolgozni, beleértve a tárolt eljárások futtatását, a tranzakciók megnyitását, az elkülönítési mód megváltoztatását... De a hibakeresési munkamenetünk mindvégig ugyanabban a tranzakcióban fog zajlani, mint az alkalmazás.
Tegyük fel, hogy egy alkalmazás zárol egy táblázatot, és elkezdi módosítani a tartalmát. Ebben a pillanatban semmilyen más kapcsolat nem nézhet be a lezárt asztalba. De nem a mi hibakereső munkamenetünk! Innentől ugyanúgy nézhetjük meg az adatbázist, mint az alkalmazás, mivel az SQL szerver úgy gondolja, hogy ugyanabban a tranzakcióban vagyunk.
Míg az összes többi munkamenetben az alkalmazás műveleteit zárak rejtik...
A hibakereső munkamenetünk átmegy a zárakon (a szerver azt hiszi, hogy ezek a saját záraink)!
Vagy képzelje el, hogy az alkalmazás elkezd dolgozni a saját karakterlánc-verzióival SNAPSHOT módban. Hogyan nézhetem meg ezeket a verziókat? Még ez is lehetséges, ha közös tranzakció köt össze!
Ne felejtse el visszavonni az ellenőrzési tranzakciót ennek az izgalmas folyamatnak a végén. Ez mind a hibakeresési munkamenetből (ha a tesztelési folyamat normálisan befejeződik), mind az alkalmazásból (ha valami váratlan történik benne) megtehető.
Erről többet megtudhat a tanfolyamokon
Adatbázis tesztelés nem olyan gyakori, mint az alkalmazás más részeinek tesztelése. Néhány tesztben adatbázisáltalában nedvesek. Ebben a cikkben megpróbálom megvizsgálni a relációs és a tesztelési eszközöket NoSQL adatbázisok.
Ez a helyzet abból adódik, hogy sok adatbázis kereskedelmi jellegű, és a velük való munkához szükséges eszközök teljes készletét az adatbázist fejlesztő szervezet biztosítja. A NoSQL és a különféle MySQL forkok növekvő népszerűsége azonban a jövőben megváltoztathatja ezt az állapotot.
Adatbázis Benchmark
A Database Benchmark egy .NET-eszköz, amelyet nagy adatfolyamot tartalmazó adatbázisok terheléses tesztelésére terveztek. Az alkalmazás két fő tesztelési forgatókönyvet futtat: nagyszámú véletlenszerűen generált rekord beszúrása szekvenciális vagy véletlenszerű kulcsokkal, és a beillesztett rekordok beolvasása a kulcsaik szerint. Széleskörű képességekkel rendelkezik adatok, grafikus jelentések generálására és a lehetséges jelentéstípusok konfigurálására.
Támogatott adatbázisok: MySQL, SQL Server, PostgreSQL, MongoDB és még sokan mások.
Adatbázis Rider
A Database Rider-t úgy tervezték, hogy lehetővé tegye a tesztelést volt egy adatbázis nem volt nehezebb, mint az egységteszt. Ez az eszköz azon alapul Arquillianés ezért a Java projektnek csak a DBUnit függőségére van szüksége. Lehetőség van annotációk használatára is, mint plJUnit, integráció a CDI elfogókon keresztül, JSON, YAML, XML, XLS és CSV támogatása, konfiguráció ugyanazon annotációk segítségével, ill. yml fájlok, integráció Uborka, több adatbázis támogatása, ideiglenes típusokkal való munka az adatkészletekben.
DbFit
DbFit - fejlesztési keretrendszer Adatbázis tesztelés révén. A tetejére van írva FitNesse, amely egy kiforrott és hatékony eszköz egy nagy közösséggel. A tesztek táblázatok alapján készülnek, így olvashatóbbak, mint a hagyományosak egység - tesztek. Futtathatja őket az IDE-ből, a parancssorból vagy a CI-eszközök segítségével.
Támogatott adatbázisok: Oracle, SQL Server, MySQL, DB2, PostgreSQL, HSQLDB és Derby.
dbstressz
A dbstress egy Scala és Akka nyelven írt adatbázis-teljesítmény- és stressz-tesztelő eszköz. Egy speciális JDBC-driver, bizonyos számú alkalommal párhuzamosan hajtja végre a kéréseket (esetleg több géphez is), és a végeredményt elmenti csv fájlt.
Támogatott adatbázisok: ugyanaz, mint a JDBC-ben.
DbUnit
egy kiterjesztése JUnit (hangya-val is használatos), amely a tesztek között visszatérhet adatbázis a kívánt állapotba. Ez a funkció lehetővé teszi a tesztek közötti függőségek elkerülését; ha az egyik teszt meghiúsul, és ugyanakkor sérti az adatbázist, akkor a következő teszt a nulláról indul. A DbUnit képes adatokat átvinni egy adatbázis és egy XML dokumentum között. Streaming módban is lehet dolgozni nagy adatkészletekkel. Azt is ellenőrizheti, hogy az eredményül kapott adatbázis megfelel-e egy bizonyos szabványnak.
Támogatott adatbázisok: ugyanaz, mint a JDBC-ben.
DB tesztvezérelt
A DB Test Driven egy eszköz a egység - tesztelés Adatbázis. Ez a segédprogram nagyon könnyű, natív SQL-lel működik, és közvetlenül az adatbázisba telepíthető. Könnyen integrálható a folyamatos integrációs eszközökkel, és az SQL Server verzió képes tesztelni a kódlefedettséget.
Támogatott adatbázisok: SQL Server, Oracle.
HammerDB
HammerDB - terhelési és benchmark tesztelő eszköz Adatbázis. Ez egy automatizált alkalmazás, amely szintén többszálú, és képes dinamikus szkriptek használatára. Nyílt forráskódú jav és összehasonlító eszköz. Automatizált, többszálú, és dinamikus szkriptek támogatásával bővíthető.
JdbcSlim
A JdbcSlim a lekérdezések és parancsok egyszerű integrálását kínálja a Slim FitNesse-be. A projekt középpontjában a konfigurációk, a tesztadatok és az SQL tárolása áll. Ez biztosítja, hogy a követelmények a megvalósítástól függetlenül legyenek megírva, és érthetőek az üzleti felhasználók számára. A JdbcSlim nem rendelkezik adatbázis-specifikus kóddal. Agnosztikus az adatbázisrendszer sajátosságaival kapcsolatban, és nincs konkrét kódja egyetlen adatbázisrendszerhez sem. Magában a keretrendszerben minden magas szinten le van írva, minden konkrét dolog megvalósítása egyetlen osztály megváltoztatásával történik.
Támogatott adatbázisok: Oracle, SQL Server, PostgreSQL, MySQL és mások.
JDBDT (Java DataBase Delta Testing)
A JDBDT egy Java könyvtár (SQL alapú) adatbázis-alkalmazások tesztelésére. A könyvtárat az adatbázistesztek automatizált telepítésére és tesztelésére tervezték. JDBDT nincs függősége harmadik féltől származó könyvtáraktól, ami leegyszerűsíti az integrációt. A meglévő adatbázis-tesztelő könyvtárakhoz képest a JDBDT fogalmilag különbözik a δ-állítások használatának képességében.
Támogatott adatbázisok: PostgreSQL, MySQL, SQLite, Apache Derby, H2 és HSQLDB.
NBi
Az NBi lényegében az NUnit kiegészítője, és inkább erre szolgál Üzleti intelligencia gömbök. A relációs adatbázisokkal való munka mellett lehetőség van a OLAP platformok (Analysis Services, Mondrian stb.), ETLÉs jelentési rendszerek(Microsoft technológiák). Ennek a keretrendszernek a fő célja tesztek létrehozása XML-alapú deklaratív megközelítéssel. Nem kell teszteket írnia C#-ban, és nem kell a Visual Studio-t használnia tesztek összeállításához. Csak létre kell hoznia egy xml fájlt, és értelmeznie kell az NBi segítségével, majd futtathatja a teszteket. A NUnit mellett más tesztkeretrendszerekre is átvihető.
Támogatott adatbázisok: SQL Server, MySQL, PostgreSQL, Neo4j, MongoDB, DocumentDB és mások.
NoSQLMap
A NoSQLMap Python nyelven íródott, hogy robusztusság-auditálást végezzen sql - injekciókés különféle kihasználások az adatbázis konfigurációjában. És egy NoSQL adatbázisokat használó webalkalmazás ilyen típusú támadásokkal szembeni ellenállásának felmérésére is. Az alkalmazás fő céljai, hogy eszközt biztosítsanak a MongoDB szerverek teszteléséhez ill eloszlatva azt a mítoszt, hogy a NoSQL alkalmazások áthatolhatatlanok az SQL injekcióhoz.
Támogatott adatbázisok: MongoDB.
NoSQLUnit
A NoSQLUnit a JUnit kiterjesztése, amelyet NoSQL-adatbázisokat használó Java-alkalmazások tesztjére terveztek. Cél NoSQLUnit— a NoSQL életciklusának kezelése. Ez az eszköz segít karbantartani a tesztelt adatbázisokat ismert állapotban, és szabványosítani a NoSQL-t használó alkalmazások tesztírásának módját.
Támogatott adatbázisok: MongoDB, Cassandra, HBase, Redis és Neo4j.
ruby-plsql-spec
ruby-plsql-spec keretrendszer a PL/SQL egység teszteléséhez Ruby használatával. Két másik könyvtáron alapul:
- ruby-plsql – Ruby API PL/SQL eljárások hívásához;
- Az RSpec a BDD keretrendszere.
Támogatott adatbázisok: Oracle
SeLite
A SeLite a Selenium család kiterjesztése. A fő ötlet az, hogy legyen egy adatbázisunk SQLite, elkülönítve az alkalmazástól. Képes lesz észlelni a webszerver hibáit, és megzavarhatja a szkripteket a tesztek között, dolgozhat pillanatképekkel stb.
Támogatott adatbázisok: SQLite, MySQL, PostgreSQL.
sqlmap
Az sqlmap egy behatolást vizsgáló eszköz, amely automatizálhatja az SQL injekciók észlelésének és kihasználásának, valamint az adatbázis-kiszolgálók átvételének folyamatát. Erőteljes észlelőmotorral és számos niche tesztelési funkcióval van felszerelve.
Támogatott adatbázisok: MySQL, Oracle, PostgreSQL, SQL Server, DB2 és mások.
Nyílt forráskódú eszközök az adatbázis teszteléséhez
https://site/wp-content/uploads/2018/01/data-base-testing-150x150.png
Az adatbázistesztelés nem olyan gyakori, mint az alkalmazás más részeinek tesztelése. Egyes tesztekben az adatbázist teljesen kigúnyolják. Ebben a cikkben megpróbálom elemezni a relációs és NoSQL adatbázisok tesztelésére szolgáló eszközöket. Ez a helyzet annak a ténynek köszönhető, hogy sok adatbázis kereskedelmi jellegű, és a velük való munkához szükséges eszközök teljes készletét egy olyan szervezet biztosítja, amely […]
1) Célok és célkitűzések…………………………………………………………… 3
2) Az adatbázis leírása ………………………………………………………… 4
3) Munka az adatbázissal ………………………………………………………… 6
4) Az adatbázis terhelési tesztelése…………………………………..11
5) Következtetés……………………………………………………………………….15
6) Irodalom………………………………………………………………….16
Célok és célkitűzések
Cél: hozzon létre egy adatbázist az elixírekről a The Witcher 3 játékhoz, amely információkat tartalmaz az elixírek típusáról, tulajdonságairól, miből készülnek, a helyekről, ahol megtalálhatók, és a szörnyekről, amelyek ellen felhasználhatók. Hozzon létre optimalizált lekérdezéseket ehhez az adatbázishoz, és tesztelje a terhelést.
Feladatok:
· Hozzon létre legalább 5 entitást tartalmazó adatbázissémát a MYSQL Workbenchben. Ismertesse ezeket az entitásokat és kapcsolataikat!
· Ismertesse az adatbázis használatát, írja le a főbb lekérdezéseket, nézze meg a végrehajtási időt és vonjon le következtetéseket
· Adatbázis optimalizálás
· Terhelési teszt végrehajtása apache-jmeter használatával. Grafikonok készítéséhez használjon kiterjesztéseket.
Adatbázis leírása
A kurzusmunka a létrehozott Witcher1 adatbázist használja, melynek fő entitásai táblák:
1. ábra A Witcher1 adatbázis sematikus ábrázolása
Az Ingridients táblázat tartalmazza a játékban elixírek készítéséhez szükséges összetevőket, amelyek leírása az Elixírek táblázatban található. Számos összetevőt használnak az elixír elkészítéséhez, de mindegyik egyedi elixírre vonatkozik. Ez az oka annak, hogy 1: n (egy a sokhoz) kapcsolat jött létre ezen táblák között, amelyet az adatbázis diagramja mutat be (1. ábra).
Az Ingridients táblázat információkat tartalmaz az összetevők nevéről (Discription) és arról is, hogy ez az összetevő hol található (WhereFind). Az idElixirs oszlop az Ingridients és az Elixirs táblák hivatkozási oszlopa.
Az Elixírek táblázat egy adott elixír használatára vonatkozó információkat és az elixír nevét tartalmazza. Ez a táblázat a többi tábla kulcstáblázata.
A Helyek táblázat információkat tartalmaz arról, hogy egy adott összetevő melyik helyen vagy városban található.
Az IL táblázat összevont információkat tartalmaz arról, hogy egy adott területen hol és hogyan lehet megtalálni egy adott összetevőt, és mi az. Egy n:m (sok to sok) kapcsolat jött létre az Ingridients és Locations táblák között, mivel több összetevő több helyen is megtalálható, amint azt az IL gyermektáblázat is jelzi.
A Szörnyek táblázat információkat tartalmaz a szörnyek típusairól
„Witcher 3”, arról, hogyan lehet felismerni ezt vagy azt a szörnyet, és a rájuk jellemző neveket.
Az ML tábla a Hely és Szörnyek táblák n: m uniójának gyermektáblázata, és konkrét információkat tartalmaz arról, hogyan lehet legyőzni ezt a szörnyet, és milyen elixírek használhatók erre, beleértve a speciális witcher jeleket, valamint, hogy milyen területen. és milyen jeleket kell használni ennek a szörnytípusnak a kereséséhez?
Munka az adatbázissal
A Witcher1 adatbázis tartalmaz információkat arról, hogy melyik szörnyek ellen milyen elixíreket kell használni, speciális taktikákat a különösen veszélyes szörnyekre, mint pl.: Pestilence Maiden, Devil, Imp, Goblin stb. Az egyes táblák információinak sorrendben történő elemzése sok időt vesz igénybe, ezért speciális lekérdezéseket készítünk az adatbázisba, amelyek a lehető leghasznosabbak lesznek a felhasználó számára.
· Információkérés egy adott szörny megtalálásával kapcsolatban.
Ez a lekérdezés a JOIN kulcsszót fogja tartalmazni, aminek köszönhetően elérhető lesz a Witcher1 adatbázis ML és Monsters táblája.
Ez a kérés így fog kinézni:
ml JOIN monsters ON monsters.idMonsters=ml.idMonsters;
A lekérdezés végrehajtása után egy meglehetősen nagy táblát kapunk kimenetként, ami két tábla kombinálásának eredménye. Annak érdekében, hogy a megjelenített táblázat ne legyen olyan hatalmas, megadhatja, hogy melyik szörnyről jelenítsen meg információkat. Vagyis például Neki a kérés így fog kinézni:
monsters.MonstersName, monsters.MonstersDiscription,
ml.DiscriptionHowFind, ml.idLocations
ml JOIN monsters ON monsters.idMonsters=ml.idMonsters
ahol szörnyek.MonstersName='Him';
Hogy melyik szörnynek felel meg ez vagy az az azonosító, azt a Monsters vagy ML táblák lekérdezésével lehet megtudni. A lekérdezések így fognak kinézni:
KIVÁLASZTÁS KIVÁLASZTÁS
IdMonsters, MonstersName idMonsters, MonstersName
TÓL ml; A szörnyektől;
A megfelelőség ellenőrzéséhez lekérdezheti az ML és a Monsters táblát is, először az idMonsters segítségével csatlakoztassa őket.
ml.idMonsters, monsters.MonstersName
ml JOIN monsters ON
ml.idMonsters=monsters.idMonsters
MEGRENDELÉS: monsters.idMonsters;
· Egy kérés, hogy milyen elixír megfelelő ehhez a szörnyeteghez.
A kérés végrehajtásához JOIN kerül felhasználásra. A lekérdezés két Elixírek és Szörnyek asztalhoz fog szólni, és információkat tartalmaz arról, hogy mikor és milyen elixírt kell inni a szörny elleni küzdelemben:
monsters.MonstersName ,elixirs.ElixirName, elixirs.ElixirDiscription
elixírek JOIN monsters ON
elixírek.idElixírek=szörnyek.idElixírek;
· Lekérdezés arról, hogy milyen összetevő található egy adott területen.
A kérés végrehajtásához JOIN kerül felhasználásra. A lekérdezés két táblához lesz címezve: Ingridients és Locations, és információkat tartalmaz arról, hogy melyik összetevő melyik helyen található, valamint információkat a típusáról:
összetevők. Leírás, helyek. Leírás, összetevők. Hol található
összetevők CSATLAKOZÁS a helyszínekhez BE
ingridients.idIngridients=locations.idIngridients
RENDELÉS összetevők szerint.Leírás;
· UPDATE kérések
Ezt a lekérdezést egy szörnyre valósítjuk meg a Hym nevű Monsters táblában. Tegyük fel, hogy a nevét rá akarjuk változtatni:
szörnyek
SET MonstersName="Ő"
ahol idMonsters=1;
De mivel az angol verzióban Hymnek van igaza, térjünk vissza mindent:
szörnyek
SET MonstersName="Hym"
ahol idMonsters=1;
2. ábra. UPDATE lekérdezések végrehajtása
· „Aggregációs” lekérdezések. COUNT és COUNT (DISTINCT)
A COUNT függvény megszámolja az adott táblázatban lévő nem üres sorok számát (a NULL nélkül). A COUNT optimalizált verzióval rendelkezik a sorok számának megjelenítésére, ha 1 táblázathoz használják. Például:
3. ábra. Számold meg a sorokat az Elixírek, Szörnyek és Szörnyek CSATLAKOZÁS ELixírek táblázatában.
A COUNT(DISTINCT) függvény a nem ismétlődő sorok számának megjelenítésére szolgál a táblázatokban, és a COUNT függvénycsalád optimalizáltabb változata:
4. ábra. Nem ismétlődő elixírek számolása a Szörnyek táblázatában.
· TÖRLÉS funkció.
Adjunk hozzá még egy sort az Elixirs táblához az INSERT segítségével:
INSERT INTO elixírek VALUES (6,'ForDelete','DiscriptionDelete');
5. ábra. Egy sor hozzáadása az Elixírek táblához.
Most kérni fogjuk ennek a sornak a törlését, mivel nincs szükség olyan elixírre, amely semmilyen módon nem segít a szörnyek elleni küzdelemben:
DELETE FROM elixirs WHERE idElixirs=6;
6. ábra. Törölje a hozzáadott sort.
Adatbázis terhelési tesztelése
Most, hogy a lekérdezések befejeződtek és az adatbázishoz való hozzáférés létrejött, több paraméterrel tesztelhető:
· Response Times Over Time vagy Response Times Over Time – ez az ellenőrzés az egyes kérések átlagos válaszidejére vonatkozó információkat jelenít meg ezredmásodpercben.
· Válaszidő-elosztás vagy válaszidő-elosztás – ez az ellenőrzés a válaszok számát jeleníti meg egy adott időintervallumban, amely alatt a kérést végrehajtották.
· Válaszidő százalékos értékei – Ez az ellenőrzés százalékpontokat jelenít meg a válaszidő értékekhez. A grafikonon az X tengely százalékok, az Y tengely pedig a válaszidő.
A legvalószínűbb tesztekhez bizonyosakat fogunk beállítani
lehetőségek:
7. ábra. Tesztparaméterek
Szálak száma (felhasználók) – Virtuális felhasználók száma. Esetünkben 1000-re állítjuk, hogy az adatbázisunkat minél jobban betöltsük.
Felfutási időszak – az az időszak, amely alatt minden felhasználó részt vesz.
Ellenőrizzük az összes JOIN kérés teljesítményét, ha több felhasználó egyszerre aktiválja.
Az utolsó 3 pont az ellenőrzések plotterei, amelyekkel teszteljük az adatbázist.
· 
A válaszidők időbeli ellenőrzése
7. ábra. A teszt során végrehajtott lekérdezések eredménye Válaszidők idővel
Amint az a grafikonon látható, a legnehezebben teljesíthető kérés a „Monsters&Locations” volt, és a leghosszabb válaszidőt igényelte. A kérés hosszú végrehajtásának okát úgy ellenőrizheti, hogy a konzolban futtatja a kérést. Ennek a késedelemnek a fő oka az, hogy mind a Monsters, mind az ML tábla hosszadalmas magyarázatokat tartalmaz a szörnyekről vagy azok megtalálásáról. Emiatt a kérés teljesítése meglehetősen hosszú időt vesz igénybe.
· 
Vizsgálat Válaszidő-eloszlás
8. ábra. A teszt során végrehajtott lekérdezések eredménye Válaszidő-eloszlás.
Ebből a grafikonból azt a következtetést vonhatjuk le, hogy minden egyes kérésünkre ugyanabban az időszakban adott válaszok száma azonos.
· 
A válaszidő százalékos értékeinek ellenőrzése
Az ordináta tengely a végrehajtási időt, az abszcissza tengely pedig a teljes mennyiség százalékát mutatja. A grafikon alapján megállapíthatjuk, hogy a kérések 90%-a 0-tól 340 ezredmásodpercig terjedő időintervallumban hajtódik végre, 5%-ról 15%-ra pedig lineárisan, majd exponenciálisan, igen kis növekedési együtthatóval nő a kérések száma.
A fennmaradó 10% 340 ezredmásodperctől 700 ezredmásodpercig terjedő időintervallumban kerül végrehajtásra, ami arra enged következtetni, hogy nagyon nagy terhelés van az adatbázison.
Következtetés
Ebben a tanfolyami munkában minden feladatot teljesítettek. Az adatbázist megterveztük, feltöltöttük adatokkal, bemutattuk lekérdezések formájában történő felhasználásának főbb lehetőségeit és azok végrehajtási eredményeit.
A végén tesztelésre és eredményeinek elemzésére került sor, az ezt követő következtetésekkel.
Megjegyzendő, hogy maga az adatbázis csak oktatási jellegű, tehát nem olyan terjedelmes.
Egy másik fontos jellemző a biztonság: a jelszavakat, ha ilyen táblát hoznak létre, titkosított formában kell tárolni, és védeni kell az illetéktelen hozzáféréstől.
Irodalom
1. http://phpclub.ru/mysql/doc/- Internetes forrás "MySQL - referencia útmutató"
2. Schwartz B., Zaitsev P., Tkachenko V. és társai - MySQL. A teljesítmény optimalizálása (2. kiadás)
3. Thalmann L., Kindal M., Bell C. – „MySQL alapú rendszerek magas rendelkezésre állásának biztosítása”
4. Andrzej Sapkowski – „The Witcher (nagy gyűjtemény)”, Oldalszám: 571
5. CD PROJECT RED, GOG COM. "The Witcher 3: Wild Hunt."
Kapcsolódó információ.
Az adatbázis működőképességének biztosításához adatbázisteszt szükséges. Ehhez különféle típusú lekérdezések készülnek az adatbázisban: mintavételre, számított mezőkkel, paraméteres, adatcsoportosítással, frissítésre, törlésre.
Példalekérdezés: Egy adott tanuló által készített könyvek listájának megjelenítése. Állítsa be paraméterként a teljes nevét.
Példalekérdezés: Megjeleníti egy adott szerző könyveinek listáját, megjelölve a tárhelyet a könyvtárban. Paraméterként állítsa be a szerző teljes nevét.
Példakérelem: Határozza meg a könyvtári igazolvány száma alapján, hogy a megfelelő tanuló melyik osztályba jár és ki az osztályfőnöke.
Rizs. 15. Lekérdezés 3. „Keressen meg egy diákot a könyvtári igazolvány száma alapján, és határozza meg, melyik osztályban tanul”
Példa kérésre: Határozza meg a tanuló teljes nevével, hogy az adós melyik osztályban tanul, és ki az osztályfőnöke.
A különféle táblák rekordjaival való munka kényelme érdekében létrehozták, amellyel bármilyen tábla megnyitható az információk megtekintéséhez, frissítéséhez és módosításához. A gomb formája az ábrán látható. 17.
Rizs. 17. Adatbázis gomb űrlap
KÖVETKEZTETÉS
A végső minősítő munka az aktuális „Vidéki iskolai könyvtár információs rendszerének fejlesztése” témakörben zajlott.
Az oklevélterv célja, hogy információs rendszert fejlesszen ki a Szaratovi régió iskolai könyvtára számára, az önkormányzati oktatási intézmény középiskolai Fedorovszkij kerülete számára Solnechny faluban.
Az érettségi során a következő feladatokat oldották meg:
Tekintse a könyvtárat az oktatási környezet elemének;
Tanulmányozza a kormányzati koncepciót a gyermekek olvasásának támogatásáról és fejlesztéséről;
Elemezzük az oktatási intézmények könyvtárainak munkatechnológiáit;
A témakör leírása a felmérés alapján történik;
-kidolgozták a vidéki iskolai könyvtár információs rendszerének fejlesztésére vonatkozó műszaki specifikációt;
- kiépült az iskolai könyvtár tevékenységének funkcionális modellje;
- a bemeneti és kimeneti információáramlás leírása;
DBMS-en alapuló információs rendszert fejlesztettek kiACCess;
- a kifejlesztett relációs adatbázist teszteltük.
A kézi műveletek automatizálását biztosító információs rendszer felépítésének végső minősítő munkája során a hallgatók tárolási, keresési, kiadási és visszaküldési folyamatait biztosító műszaki specifikációt dolgoztak ki egy felmérés eredményeinek elemzése alapján. a tárgyterületről. A műszaki előírások (TOR) a rendszerhasználók – könyvtári dolgozók – igényeit tükrözték.
A műszaki előírások alapján kidolgozásra került egy vidéki iskolai könyvtár tevékenységének funkcionális modellje. A funkcionális modell pedig anyagként szolgált a nem automatizált területek azonosításához a könyvtári munkában.
A DBMS, mint fejlesztői környezet kiválasztását a vidéki könyvtár technikai adottságai határozták meg. Ennek eredményeként a DBMS alapján HozzáférésKiépült az információs rendszer magja – az adatbázis.
A felhasználók kényelme érdekében egy nyomógombos felületet fejlesztettek ki.
Megfelelő lekérdezéseket fejlesztettek ki az adatbázis tesztelésére. Ezeknek a lekérdezéseknek a kitöltése lehetővé teszi, hogy megítéljük egy vidéki iskolai könyvtár információs rendszerének normál teljesítményét.
BIBLIOGRÁFIAI LISTÁJA
