Laravel tillhandahåller många användbara verktyg för att testa dina databasapplikationer. Först kan du använda PHP-hjälpmetoden seeInDatabase() att kontrollera att data i databasen uppfyller en viss uppsättning kriterier. Till exempel, om du vill kontrollera att användartabellen har en post med e-postfältet lika med [e-postskyddad], kan du göra följande:
PHP
{
// Ringer ett ansökningssamtal...
$this -> seeInDatabase("användare" , [
"e-post" => " [e-postskyddad]"
]);
}
Naturligtvis metoder som PHP seeInDatabase() skapad för bekvämlighet. Du kan använda vilken som helst av PHPUnits inbyggda valideringsmetoder för att utöka dina tester.
Återställ databasen efter varje test
Det är ofta användbart att återställa din databas efter varje test så att data från det föregående testet inte påverkar efterföljande tester.
Använder migrationer
Ett sätt att återställa databastillståndet är att återställa databasen efter varje test och migrera den före nästa test. Laravel tillhandahåller en enkel DatabaseMigrations-egenskap som automatiskt gör detta åt dig. Använd bara den här egenskapen på din testklass så kommer allt att göras åt dig:
PHP /**
{
använd Databasmigrations;
*
* @retur ogiltig
*/
{
$this -> besök ("/" )
-> se ("Laravel 5" );
}
}
Använda transaktioner
Ett annat sätt att återställa DB-tillståndet är att slå in varje testfall i en DB-transaktion. Och för detta tillhandahåller Laravel också en praktisk DatabasTransactions-egenskap som automatiskt gör detta åt dig:
PHP Använd Illuminate\Foundation\Testing\WithoutMiddleware; class ExempelTest utökar TestCase /**
använd Illuminate\Foundation\Testing\Databasmigrations;
använd Illuminate\Foundation\Testing\Databastransaktioner;
{
använda DatabasTransactions ;
* Exempel på ett grundläggande funktionstest.
*
* @retur ogiltig
*/
{
$this -> besök ("/" )
-> se ("Laravel 5" );
}
}
Som standard kommer denna egenskap endast att linda standarddatabasanslutningen i en transaktion. Om din applikation använder flera databasanslutningar måste du definiera PHP-egenskapen $connectionsToTransact i din testklass. Den här egenskapen bör vara en uppsättning anslutningsnamn att utföra transaktioner på.
Skapande av fabriker
När du testar kan du behöva infoga flera poster i din DB innan du kör testet. När du skapar dessa data, istället för att manuellt specificera värdena för varje kolumn, låter Laravel dig definiera en standarduppsättning attribut för var och en av dina Eloquent-modeller med hjälp av fabriker. Titta först på databasen/factorys/ModelFactory.php-filen i din ansökan. Till en början innehåller den här filen definitionen av en fabrik:
PHP $factory -> define (App \ User ::klass, funktion (Faker \ Generator $faker ) (
statiskt $password ;
Lämna tillbaka [
"name" => $faker -> namn ,
"email" => $faker -> unique()-> safeEmail ,
"password" => $password ?: $password = bcrypt ("hemligt") ,
"remember_token" => str_random (10 ),
];
});
I en stängning som fungerar som en fabriksdefinition kan du returnera standardtestvärden för alla modellattribut. Stängningen kommer att få en instans av Faker PHP-biblioteket, vilket gör att du enkelt kan generera olika slumpmässiga data för testning.
Naturligtvis kan du lägga till dina egna ytterligare fabriker i filen ModelFactory.php. Du kan också skapa ytterligare fabriksfiler för varje modell för tydligare organisation. Till exempel kan du skapa UserFactory.php- och CommentFactory.php-filer i din databas/fabriksmapp. Alla filer i fabriksmappen kommer automatiskt att laddas ner av Laravel.
Fabriksstater
Tillstånd tillåter dig att definiera individuella ändringar som kan tillämpas på dina modellfabriker i valfri kombination. Till exempel kan din användarmodell ha ett brottsligt tillstånd som ändrar standardvärdet för ett av attributen. Du kan definiera dina tillståndstransformationer med PHP-metoden stat() :
PHP $factory -> state (App \ User ::class, "delinquent" , function ($faker ) (
lämna tillbaka [
"account_status" => "brottslig" ,
];
});
Använder fabriker
Skapa modeller
När fabrikerna är definierade kan du använda PHP globala funktionen fabrik() i dina tester eller seed-filer för att generera modellinstanser. Så låt oss titta på några exempel på att skapa modeller. För det första använder vi PHP-metoden göra() för att skapa modeller, men kommer inte att spara dem i databasen:
PHP public function testDatabase()
{
$user = fabrik (App\User::class)->make();
Du kan också skapa en samling modeller eller skapa modeller av en specifik typ:
PHP $users = fabrik (App\User::class, 3)->make();
Du kan också tillämpa vilken som helst på modeller. Om du vill tillämpa flera tillståndsändringar på modeller måste du ange namnet på varje stat som ska tillämpas:
PHP $users = fabrik (App \ User ::class, 5 )-> stater ( "delinquent") -> make ();
$users = fabrik (App \ User ::class, 5 ) -> tillstånd ( "premium", "delinquent") -> make ();
Attribut Override
Om du vill åsidosätta några av standardvärdena för dina modeller kan du skicka en rad värden till PHP-metoden göra(). Endast de angivna värdena kommer att ersättas, och resten kommer att ställas in enligt fabriken:
PHP $user = fabrik (App\User::class)->make ([
"name" => "Abigail" ,
]);
Permanenta modeller
PHP-metod skapa() skapar inte bara modellinstanser, utan lagrar dem också i databasen med hjälp av Eloquent PHP-metoden spara() :
PHP public function testDatabase()
{
// Skapa en instans av App\User...
$user = fabrik (App\User::class)->create();
// Skapa tre instanser av App\User...
$users = fabrik (App\User::class, 3)->create();
// Att använda modellen i tester...
}
Du kan åsidosätta modellattribut genom att skicka en array till en PHP-metod skapa():PHP make());
});
Avslutande relationer och attribut
Du kan också koppla relationer till modeller med stängningsattribut i dina fabriksdefinitioner. Om du till exempel vill skapa en ny instans av användarmodellen när du skapar ett inlägg, kan du göra så här:
PHP $factory ->
lämna tillbaka [
"title" => $faker -> titel ,
"content" => $faker -> stycke ,
"user_id" => funktion() (
return factory (App\User::class)->create()->id;
}
];
});
Denna stängning får också en specifik uppsättning attribut från fabriken som innehåller den:
PHP $factory -> define (App \ Post ::klass, funktion ($faker ) (
lämna tillbaka [
"title" => $faker -> titel ,
"content" => $faker -> stycke ,
"user_id" => funktion() (
return factory (App\User::class)->create()->id;
},
"user_type" => funktion (array $post ) (
returnera App\User::find($post["user_id"])->typ;
}
];
});
: Hur man testar och felsöker databaser
Automatisk enhetstestning av applikationskod är enkel och okomplicerad. Hur testar man en databas? Eller ett program som fungerar med en databas. En databas är trots allt inte bara programkod, en databas är ett objekt som sparar dess tillstånd. Och om vi börjar ändra data i databasen under testning (och utan detta, vilken typ av testning kommer vi att ha?!), så kommer databasen att ändras efter varje test. Detta kan störa efterföljande tester och permanent korrumpera databasen.
Nyckeln till att lösa problemet är transaktioner. En av funktionerna i den här mekanismen är att så länge som transaktionen inte är slutförd kan du alltid ångra alla ändringar och återställa databasen till den status då transaktionen började.
Algoritmen är så här:
- öppna en transaktion;
- vid behov utför vi förberedande steg för testning;
- utför ett enhetstest (eller kör helt enkelt skriptet vars operation vi vill kontrollera);
- kontrollera resultatet av skriptet;
- Vi avbryter transaktionen och återställer databasen till dess ursprungliga tillstånd.
Även om det finns oavslutade transaktioner i koden som testas kommer den externa ROLLBACK fortfarande att återställa alla ändringar korrekt.
Det är bra om vi behöver testa ett SQL-skript eller en lagrad procedur. Vad händer om vi testar en applikation som själv ansluter till databasen och öppnar en ny anslutning? Dessutom, om vi felsöker, kommer vi förmodligen att vilja titta på databasen genom ögonen på den applikation som felsöks. Vad ska man göra i det här fallet?
Ha inte bråttom att skapa distribuerade transaktioner, det finns en enklare lösning! Med standardverktyg för SQL-server kan du öppna en transaktion på en anslutning och fortsätta den på en annan.
För att göra detta måste du ansluta till servern, öppna en transaktion, skaffa en token för den transaktionen och sedan skicka denna token till applikationen som testas. Den kommer att gå med i vår transaktion i sin session och från det ögonblicket kommer vi i vår felsökningssession att se data (och även känna låsen) exakt som applikationen som testas ser den.
Sekvensen av åtgärder är som följer:
Efter att ha startat en transaktion i en felsökningssession måste vi ta reda på dess identifierare. Detta är en unik sträng med vilken servern särskiljer transaktioner. Denna identifierare måste på något sätt skickas till applikationen som testas.
Nu är applikationens uppgift att binda till vår kontrolltransaktion innan den börjar göra vad den ska göra.
Sedan börjar applikationen att fungera, inklusive att köra sina lagrade procedurer, öppna sina transaktioner, ändra isoleringsläge... Men vår felsökningssession kommer hela tiden att vara i samma transaktion som applikationen.
Låt oss säga att ett program låser en tabell och börjar ändra dess innehåll. För närvarande kan inga andra anslutningar titta in i det låsta bordet. Men inte vår felsökningssession! Därifrån kan vi titta på databasen på samma sätt som applikationen gör, eftersom SQL-servern tror att vi är i samma transaktion.
Medan för alla andra sessioner är applikationens åtgärder dolda av lås...
Vår felsökningssession går genom låsen (servern tror att de är våra egna lås)!
Eller föreställ dig att programmet börjar arbeta med sina egna versioner av strängar i SNAPSHOT-läge. Hur kan jag titta på dessa versioner? Även detta är möjligt om du är ansluten till en gemensam transaktion!
Glöm inte att återställa kontrolltransaktionen i slutet av denna spännande process. Detta kan göras både från felsökningssessionen (om testprocessen slutförs normalt) och från själva applikationen (om något oväntat händer i den).
Du kan lära dig mer om detta i kurserna
Databastestning inte lika vanligt som att testa andra delar av applikationen. I vissa tester databas i allmänhet bli blöt. I den här artikeln ska jag försöka titta på verktyg för att testa relations- och NoSQL databaser.
Denna situation beror på det faktum att många databaser är kommersiella och hela den nödvändiga uppsättningen verktyg för att arbeta med dem tillhandahålls av den organisation som utvecklade databasen. Den växande populariteten för NoSQL och olika MySQL-gafflar i framtiden kan dock förändra detta tillstånd.
Databasbenchmark
Database Benchmark är ett .NET-verktyg utformat för att stresstesta databaser med stora dataströmmar. Applikationen kör två huvudtestscenarier: infogning av ett stort antal slumpmässigt genererade poster med sekventiella eller slumpmässiga nycklar, och läsning av infogade poster ordnade efter deras nycklar. Den har omfattande möjligheter för att generera data, grafiska rapporter och konfigurera möjliga typer av rapporter.
Databaser som stöds: MySQL, SQL Server, PostgreSQL, MongoDB och många andra.
Databas Rider
Database Rider är designad för att tillåta testning det fanns en databas var inte svårare än enhetstestning. Detta verktyg är baserat på Arquillian och därför behöver Java-projektet bara ett beroende för DBUnit. Det är också möjligt att använda anteckningar, som iJUnit, integration med CDI via interceptorer, stöd för JSON, YAML, XML, XLS och CSV, konfiguration via samma kommentarer eller yml filer, integration med Gurka, stöd för flera databaser, arbetar med temporära typer i datauppsättningar.
DbFit
DbFit - utvecklingsramverk Databas genom testning. Det är skrivet ovanpå FitNesse, som är ett moget och kraftfullt verktyg med en stor community. Tester skrivs utifrån tabeller, vilket gör dem mer läsbara än vanliga enhet - tester. Du kan köra dem från IDE, med kommandoraden eller med CI-verktyg.
Databaser som stöds: Oracle, SQL Server, MySQL, DB2, PostgreSQL, HSQLDB och Derby.
dbstress
dbstress är ett databasprestanda- och stresstestverktyg skrivet i Scala och Akka. Med hjälp av en speciell JDBC-drivrutin, den exekverar förfrågningar parallellt ett visst antal gånger (eventuellt till och med till flera värdar) och sparar slutresultatet i csv fil.
Databaser som stöds: allt samma som i JDBC.
DbUnit
är en förlängning JUnit (används även med Ant), som mellan testerna kan återkomma databas till önskat tillstånd. Den här funktionen låter dig undvika beroenden mellan testerna; om ett test misslyckas och samtidigt bryter mot databasen kommer nästa test att starta från början. DbUnit har möjlighet att överföra data mellan en databas och ett XML-dokument. Det är också möjligt att arbeta med stora datamängder i streaming-läge. Du kan också kontrollera om den resulterande databasen matchar en viss standard.
Databaser som stöds: allt samma som i JDBC.
DB Testdriven
DB Test Driven är ett verktyg för enhet - testning Databas. Detta verktyg är mycket lätt, fungerar med inbyggd SQL och installeras direkt i databasen. Integreras enkelt med kontinuerliga integreringsverktyg och SQL Server-versionen har förmågan att utvärdera kodtäckning genom tester.
Databaser som stöds: SQL Server, Oracle.
HammerDB
HammerDB - last- och benchmarktestverktyg Databas. Detta är en automatiserad applikation som också är flertrådad och har förmågan att använda dynamiska skript. Open source jav och jämförelseverktyg. Den är automatiserad, flertrådad och utbyggbar med stöd för dynamiska skript.
JdbcSlim
JdbcSlim erbjuder enkel integrering av frågor och kommandon i Slim FitNesse. Projektets fokus ligger på att lagra en rad konfigurationer, testdata och SQL. Detta säkerställer att kraven skrivs oberoende av implementeringen och är begripliga för företagsanvändare. JdbcSlim har inte databasspecifik kod. Han är agnostiker om detaljerna i ett databassystem och har ingen specifik kod för något databassystem. I själva ramverket beskrivs allt på en hög nivå, implementeringen av specifika saker sker genom att bara ändra en klass.
Databaser som stöds: Oracle, SQL Server, PostgreSQL, MySQL och andra.
JDBDT (Java DataBase Delta Testing)
JDBDT är ett Java-bibliotek för att testa (SQL-baserade) databasapplikationer. Biblioteket är designat för automatiserad installation och testning av databastesterna. JDBDT har inga beroenden av tredjepartsbibliotek, vilket förenklar integrationen. Jämfört med befintliga databastestbibliotek är JDBDT begreppsmässigt annorlunda i sin förmåga att använda δ-påståenden.
Databaser som stöds: PostgreSQL, MySQL, SQLite, Apache Derby, H2 och HSQLDB.
NBi
NBi är i huvudsak ett tillägg för NUnit och är avsett mer för Business Intelligence sfärer. Förutom att arbeta med relationsdatabaser går det att arbeta med OLAP plattformar (Analystjänster, Mondrian, etc.), ETL Och rapporteringssystem(Microsoft-teknologier). Huvudmålet med detta ramverk är att skapa tester med ett deklarativt tillvägagångssätt baserat på XML. Du behöver inte skriva tester i C# eller använda Visual Studio för att kompilera tester. Du behöver bara skapa en xml-fil och tolka den med NBi, sedan kan du köra testerna. Förutom NUnit kan den portas till andra testramverk.
Databaser som stöds: SQL Server, MySQL, PostgreSQL, Neo4j, MongoDB, DocumentDB och andra.
NoSQLMap
NoSQLMap är skrivet i Python för att utföra robusthetsgranskning sql - injektioner och olika exploateringar i databaskonfigurationen. Och även för att bedöma motståndet hos en webbapplikation som använder NoSQL-databaser mot denna typ av attack. Huvudmålen med applikationen är att tillhandahålla ett verktyg för att testa MongoDB-servrar och skingra myten att NoSQL-applikationer är ogenomträngliga för SQL-injektion.
Databaser som stöds: MongoDB.
NoSQLUnit
NoSQLUnit är ett tillägg för JUnit designat för att skriva tester i Java-applikationer som använder NoSQL-databaser. Mål NoSQLUnit— hantera NoSQL-livscykeln. Det här verktyget hjälper dig att underhålla databaserna du testar i ett känt tillstånd och standardisera hur du skriver tester för applikationer som använder NoSQL.
Databaser som stöds: MongoDB, Cassandra, HBase, Redis och Neo4j.
ruby-plsql-spec
ruby-plsql-spec ramverk för enhetstestning av PL/SQL med Ruby. Den är baserad på två andra bibliotek:
- ruby-plsql – Ruby API för anrop av PL/SQL-procedurer;
- RSpec är ett ramverk för BDD.
Databaser som stöds: Oracle
SeLite
SeLite är en förlängning från Selenium-familjen. Huvudtanken är att ha en databas baserad på SQLite, isolerad från applikationen. Du kommer att kunna upptäcka webbserverfel och fumla skript mellan tester, arbeta med ögonblicksbilder, etc.
Databaser som stöds: SQLite, MySQL, PostgreSQL.
sqlmap
sqlmap är ett penetrationstestverktyg som kan automatisera processen att upptäcka och utnyttja SQL-injektioner och ta över databasservrar. Den är utrustad med en kraftfull detektionsmotor och många nischade testfunktioner.
Databaser som stöds: MySQL, Oracle, PostgreSQL, SQL Server, DB2 och andra.
Verktyg med öppen källkod för databastestning
https://site/wp-content/uploads/2018/01/data-base-testing-150x150.png
Databastestning är inte lika vanligt som att testa andra delar av applikationen. I vissa tester är databasen helt hånad. I den här artikeln ska jag försöka analysera verktyg för att testa relations- och NoSQL-databaser. Denna situation beror på det faktum att många databaser är kommersiella och hela den nödvändiga uppsättningen verktyg för att arbeta med dem tillhandahålls av en organisation som […]
1) Mål och mål……………………………………………………………… 3
2) Beskrivning av databasen …………………………………………………………... 4
3) Arbeta med databasen ………………………………………………………… 6
4) Lasttestning av databasen…………………………………...11
5) Slutsats………………………………………………………………………………………....15
6) Litteratur………………………………………………………………………....16
Mål och syfte
Mål: skapa en databas med elixirer för spelet The Witcher 3, som kommer att innehålla information om typen av elixir, deras egenskaper, vad de är gjorda av, platser där de kan hittas och om monster mot vilka de kan användas. Skapa optimerade frågor för denna databas och ladda testa den.
Uppgifter:
· Skapa ett databasschema med minst 5 enheter i MYSQL Workbench. Beskriv dessa enheter och deras kopplingar.
· Beskriv användningen av denna databas, beskriv de viktigaste frågorna, titta på deras utförandetid och dra slutsatser
· Databasoptimering
· Utför belastningstestning med apache-jmeter. Använd tillägg för att bygga grafer.
Databasbeskrivning
Kursarbetet använder den skapade Witcher1-databasen, vars huvudenheter är tabeller:
Fig.1 Schematisk representation av Witcher1-databasen
Ingredienstabellen innehåller de nödvändiga ingredienserna för att skapa elixir i spelet, som beskrivs i tabellen Elixirer. Flera ingredienser används för att skapa ett elixir, men var och en är unik för sitt elixir. Det är av denna anledning som ett 1:n (en-till-många) förhållande etablerades mellan dessa tabeller, vilket visas i databasdiagrammet (fig. 1).
Ingredienstabellen innehåller även information om namnen på ingredienserna (beskrivning) och var denna ingrediens kan hittas (WhereFind). Kolumnen idElixirs är en länkkolumn för tabellerna Ingridients och Elixirs.
Tabellen Elixir innehåller information om hur man använder ett specifikt elixir och namnet på det elixiret. Denna tabell är nyckeltabellen för de andra borden.
Platstabellen innehåller information om vilken plats eller stad en specifik ingrediens kan hittas i.
Tabell IL innehåller samlad information om var och hur man hittar en specifik ingrediens i ett givet område och vad det är. En n:m-relation (många till många) etablerades mellan tabellerna Ingredienser och Platser, eftersom flera ingredienser kan hittas på flera platser, vilket indikeras i IL-underordnade tabellen.
Monstertabellen innehåller information om typerna av monster i
"Witcher 3", om hur man känner igen detta eller det monster och namnen som är karakteristiska för dem.
ML-tabellen är en underordnad tabell av n:m-unionen av tabellerna Location och Monsters och innehåller specifik information om hur man kan besegra just detta monster och vilka elixirer som kan användas för detta, inklusive speciella witcher-tecken, samt i vilket område och Vilka tecken ska du använda för att leta efter just den här typen av monster?
Arbeta med databasen
Witcher1-databasen innehåller information om vilka elixirer som ska användas mot vilka monster, speciell taktik för speciellt farliga monster, såsom: Pestilence Maiden, Devil, Imp, Goblin, etc. Att analysera information från varje tabell i ordning kommer att ta mycket tid, så vi kommer att skapa speciella frågor till databasen som kommer att vara så användbara som möjligt för användaren.
· En begäran om information om hur man hittar ett specifikt monster.
Denna fråga kommer att innehålla nyckelordet JOIN, tack vare vilket ML- och Monsters-tabellerna i Witcher1-databasen kommer att nås.
Denna begäran kommer att se ut så här:
ml GÅ MED monster PÅ monsters.idMonsters=ml.idMonsters;
Efter att ha kört frågan kommer vi att få en ganska stor tabell som utdata, vilket är resultatet av att kombinera två tabeller. För att den visade tabellen inte ska vara så enorm kan du specificera vilket monster du ska visa information om. Det vill säga, för till exempel Honom kommer begäran att se ut så här:
monsters.MonstersName, monsters.MonstersDiscription,
ml.DiscriptionHowFind, ml.idLocations
ml GÅ MED monster PÅ monsters.idMonsters=ml.idMonsters
where monsters.MonstersName=’Hym’;
Vilket monster detta eller det ID motsvarar kan du ta reda på genom att fråga monster- eller ML-tabellerna. Frågorna kommer att se ut så här:
VÄLJ VÄLJ
IdMonsters, MonstersName idMonsters, MonstersName
FRÅN ml; FRÅN monster;
För att kontrollera efterlevnad kan du fråga både ML- och Monsters-tabellerna, först gå med i dem av idMonsters.
ml.idMonsters, monsters.MonstersName
ml GÅ MED monster PÅ
ml.idMonsters=monsters.idMonsters
BESTÄLL EFTER monsters.idMonsters;
· En förfrågan om vilket elixir som är lämpligt för detta monster.
För att implementera denna begäran kommer en JOIN att användas. Frågan kommer att adresseras till två tabeller Elixirs och Monsters och kommer att innehålla information om när och vilket elixir man ska dricka i kampen mot monstret:
monsters.MonstersName ,elixirs.ElixirName, elixirs.ElixirDiscription
elixirer GÅ MED monster PÅ
elixirs.idElixirs=monsters.idElixirs;
· En fråga om vilken ingrediens som finns i ett visst område.
För att implementera denna begäran kommer en JOIN att användas. Frågan kommer att adresseras till två tabeller Ingredienser och Platser och kommer att innehålla information om vilken ingrediens som finns på vilken plats och information om dess typ:
ingridients.Beskrivning, platser.Beskrivning, ingridients.WhereFind
ingredienser JOIN platser PÅ
ingridients.idIngridients=locations.idIngridients
BESTÄLL EFTER ingredienser.Beskrivning;
· UPPDATERINGsbegäranden
Vi implementerar den här frågan för ett monster i monstertabellen med namnet Hym. Låt oss säga att vi vill ändra hans namn till Honom:
monster
SET MonstersName="Him"
där idMonsters=1;
Men eftersom Hym är korrekt i den engelska versionen, låt oss återställa allt:
monster
SET MonstersName="Hym"
där idMonsters=1;
Fig.2. Implementerar UPDATE-frågor
· "Aggregation"-frågor. COUNT och COUNT(DISTINCT)
Funktionen COUNT räknar antalet icke-tomma rader (utan NULL inuti dem) i en given tabell. COUNT har en optimerad version för att visa antalet rader när den används för 1 tabell. Till exempel:
Fig.3. Räkna rader i tabellerna Elixirs, Monsters och Monsters JOIN elixirs.
Funktionen COUNT(DISTINCT) används för att visa antalet icke-repeterande rader i tabeller och är en mer optimerad version av COUNT-funktionsfamiljen:
Fig.4. Räknar icke-repeterande elixir i monstertabellen.
· DELETE-funktionen.
Låt oss lägga till ytterligare en rad i tabellen Elixirs med hjälp av INSERT:
INSERT INTO elixirs VALUES (6,'ForDelete','DiscriptionDelete');
Fig. 5. Lägger till en rad i tabellen Elixirs.
Nu kommer vi att begära att radera den här raden, eftersom det inte finns något behov av ett elixir som inte hjälper på något sätt i kampen mot monster:
DELETE FROM elixirs WHERE idElixirs=6;
Fig. 6. Ta bort den tillagda raden.
Databasbelastningstestning
Nu när frågorna har slutförts och tillgången till databasen har etablerats kan den testas med flera parametrar:
· Svarstider över tid eller Svarstider över tid – denna kontroll visar information för varje begäran om dess genomsnittliga svarstid i millisekunder.
· Response Times Distribution eller Response Time Distribution - denna kontroll visar antalet svar under ett visst tidsintervall under vilket förfrågan utfördes.
· Responstidspercentiler – Denna kontroll visar percentiler för svarstidsvärden. På grafen kommer X-axeln att vara procent, och Y-axeln kommer att vara svarstiden.
För de mest rimliga testerna kommer vi att ställa vissa
alternativ:
Fig. 7. Testparametrar
Antal trådar(användare) – Antal virtuella användare. I vårt fall kommer vi att ställa in den på 1000 för att ladda vår databas så mycket som möjligt.
Ramp-Up Period – perioden under vilken alla användare kommer att vara involverade.
Vi kommer att kontrollera alla JOIN-förfrågningar för deras prestanda när de aktiveras samtidigt av flera användare.
De sista 3 punkterna är plotters av kontrollerna som vi kommer att testa databasen med.
· 
Kontrollera svarstider över tid
Fig. 7. Resultatet av att köra frågor under testet Svarstider över tid
Som framgår av grafen var den svåraste förfrågan att fylla i "Monsters&Locations" och krävde den längsta svarstiden. Du kan verifiera orsaken till den långa exekveringen av begäran genom att köra begäran i konsolen. Den främsta anledningen till denna fördröjning är att både monstertabellen och ML-tabellen innehåller långa förklaringar av monster eller var man kan hitta dem. På grund av detta tar begäran ganska lång tid att slutföra.
· 
Undersökning Fördelning av svarstider
Fig. 8. Resultatet av att köra frågor under testet Fördelning av svarstider.
Från denna graf kan vi dra slutsatsen att antalet svar för var och en av våra förfrågningar under samma tidsperiod är detsamma.
· 
Kontrollera svarstidspercentiler
Ordinataaxeln visar exekveringstiden och abskissaxeln visar procentsatser av den totala kvantiteten. Baserat på grafen kan vi dra slutsatsen att 90 % av förfrågningarna exekveras i tidsintervallet från 0 till 340 millisekunder, och från 5 % till 15 % ökar antalet förfrågningar linjärt och sedan exponentiellt med en mycket liten ökningskoefficient.
De återstående 10 % exekveras i tidsintervallet från 340 millisekunder till 700 millisekunder, vilket leder till slutsatsen att det är en mycket stor belastning på databasen.
Slutsats
I detta kursarbete genomfördes alla uppgifter. Databasen designades, fylldes med data, de huvudsakliga användningsmöjligheterna i form av frågor och deras exekveringsresultat visades.
I slutet genomfördes testning och analys av dess resultat, med efterföljande slutsatser.
Det bör noteras att själva databasen skapades som endast en pedagogisk sådan, så den är inte så omfattande.
En annan viktig egenskap är säkerhet: lösenord, om en sådan tabell skapas, måste lagras i krypterad form och skyddas från obehörig åtkomst.
Litteratur
1. http://phpclub.ru/mysql/doc/- Internetresurs "MySQL - referensguide"
2. Schwartz B., Zaitsev P., Tkachenko V. et al. - MySQL. Optimera prestanda (2nd Edition)
3. Thalmann L., Kindal M., Bell C. – "Säkerställa hög tillgänglighet för MySQL-baserade system"
4. Andrzej Sapkowski – “The Witcher (stor samling)”, Antal sidor: 571
5. CD PROJEKT RÖD, GOG COM. "The Witcher 3: Wild Hunt."
Relaterad information.
Databastestning är nödvändig för att säkerställa databasens funktionalitet. För att göra detta skapas frågor i databasen av olika slag: för provtagning, med beräknade fält, parametriska, med datagruppering, för uppdatering, för radering.
Exempelfråga: Visa en lista över böcker som tagits av en specifik elev. Ställ in ditt fullständiga namn som en parameter.
Exempelfråga: Visa en lista med böcker av en specifik författare som anger lagringsplatser i biblioteket. Ställ in författarens fullständiga namn som en parameter.
Exempelförfrågan: Bestäm med lånekortsnummer vilken klass motsvarande elev går i och vem hans klasslärare är.
Ris. 15. Fråga 3. "Hitta en student efter bibliotekskortsnummer och bestäm i vilken klass han studerar"
Exempelbegäran: Bestäm med Student_Fullnamn i vilken klass gäldenären studerar och vem hans klasslärare är.
För bekvämligheten med att arbeta med poster för olika tabeller skapades den, med vilken du kan öppna vilken tabell som helst som behövs för att visa, uppdatera och ändra information. Knappformen visas i fig. 17.
Ris. 17. Databasknappformulär
SLUTSATS
Det slutliga kvalificeringsarbetet genomfördes på det aktuella ämnet "Utveckling av ett informationssystem för ett landsbygdsskolebibliotek."
Målet med diplomdesignen för att utveckla ett informationssystem för skolbiblioteket i Saratov-regionen, Fedorovsky-distriktet i den kommunala utbildningsinstitutionen gymnasieskola i byn Solnechny har uppnåtts.
Under examensarbetet löstes följande uppgifter:
Se biblioteket som en del av den pedagogiska miljön;
Studera regeringskonceptet att stödja och utveckla barns läsning;
Teknik för arbete i bibliotek vid utbildningsinstitutioner analyseras;
Ämnesområdet beskrivs utifrån undersökningen;
-en teknisk specifikation för utveckling av ett informationssystem för ett landsbygdsskolebibliotek utvecklades;
- en funktionell modell av skolbibliotekets verksamhet byggdes;
- Beskrivning av in- och utdataflöden;
ett informationssystem baserat på ett DBMS har utvecklatsACCess;
- Den utvecklade relationsdatabasen testades.
I det slutliga kvalificeringsarbetet för konstruktionen av ett informationssystem som tillhandahåller automatisering av manuella operationer för att säkerställa processerna för lagring, sökning, redovisning av utfärdande och retur av studenter, utvecklades en teknisk specifikation baserad på en analys av resultaten av en undersökning av ämnesområdet. De tekniska specifikationerna (TOR) speglade kraven från systemanvändarna – biblioteksanställda.
Utifrån de tekniska specifikationerna har en funktionell modell av verksamheten vid ett landsbygdsskolebibliotek tagits fram. Funktionsmodellen fungerade i sin tur som material för att identifiera icke-automatiserade områden i bibliotekets arbete.
Valet av ett DBMS som utvecklingsmiljö bestämdes av landsbygdsbibliotekets tekniska kapacitet. Som ett resultat, baserat på DBMS TillgångKärnan i informationssystemet – databasen – byggdes.
För användarnas bekvämlighet har ett tryckknappsgränssnitt utvecklats.
Motsvarande frågor har utvecklats för att testa databasen. Genom att fylla i dessa frågor kan vi bedöma informationssystemets normala prestanda för ett landsbygdsskolebibliotek.
BIBLIOGRAFISK LISTA
