Databashantering med Sinatra

När vår webbapplikation har definierats och vi redan vet vad vi behöver uppnå, är det många gånger nödvändigt att uppnå en form av datapersistens, det innebär att lagra data som erhålls av den någonstans och sedan använda den och det är det som gör databasen motorer för oss.

Med då behovet av att våra data kvarstår i applikationerna är det när vi måste leta efter eller förstå hur vi ska hantera dessa operationer och även om det kan låta komplext idag finns det många verktyg som underlättar vårt arbete, till exempel finns det ORM som ger oss möjlighet att skapa strukturer som är oberoende av motorn så att vi knappast någonsin kommer att skriva en ren fråga.

I fallet med Sinatra Det finns flera pärlor som redan ansvarar för anslutningarna och administrationen av databaserna, så vi får se vad de är och hur vi kan integrera dem i vår applikation.

Välj databasmotorn

Det första steget vi måste göra är att välja rätt databasmotor för vår applikation, det finns många lösningar på marknaden och var och en med ett annat syfte, när det gäller Sinatra vi kommer i allmänhet att använda MySQL eller PostgreSQL i en produktionsmiljö, eller misslyckas med det SQLite i utvecklingsmiljöer.

När det gäller denna handledning valde vi det sista alternativet på grund av dess enkla installation och den hastighet som vi kan börja arbeta med.

Installera SQLite

För att installera denna motor, först och främst går vi till dess officiella webbplats och hämtar paketet som motsvarar vårt system, många distributioner i Linux De kommer redan med den här motorn installerad och funktionell så vi får se hur vi utför den här processen Windows.

I den föregående bilden ser vi att vi måste ladda ner de förkompilerade binärfilerna, när detta är klart ska vi packa upp dem i en mapp som heter SQLite i vår C: enhet och vi lägger till den mappen som en miljövariabel i vår VÄG. När ovanstående är gjort när du skriver sqlite3 i vår konsol bör vi se något liknande följande.

När detta steg är täckt måste vi nu ladda ner motsvarande drivrutin för Rubin, det är därför vi måste skriva följande i vår kommandokonsol:

 pärla installera sqlite3

Detta bör ge oss ett resultat som följande som indikerar att installationen av pärlan var framgångsrik för att ansluta till SQLite.

ORM

Eftersom vi har vår databasmotor är det nu tur att skaffa ORMDetta är ett verktyg som gör att vi kan konvertera tabellerna i en databas till objekt, på så sätt kan vi arbeta lättare med dem i vår applikation.

FördelDen största fördelen med ORM är att det tillåter oss att vara oberoende av motorn, eftersom vi genom att inte behöva skriva SQL -kod direkt kan ändra konfigurationen och göra motsvarande migreringar.

Naturligtvis finns det många alternativ att arbeta med Rubin och med Sinatra, men en av de vänligaste att börja är DataMapper.

Installera DataMapper

Installationen av detta ORM Det kan inte vara enklare, och detta tack vare att det också är en pärla, så vi måste helt enkelt utföra ett par instruktioner i vår konsol, det första är följande som hjälper oss att få baskomponenten:

 gem installera data_mapper

Detta bör ge ett resultat som liknar följande:

Nu när vi har basen behöver vi helt enkelt installera drivrutinen så att DataMapper kan interagera med SQLite, för detta måste vi installera följande pärla:

 gem installera dm-sqlite-adapter

Detta är vad som gör att våra applikationer kan skapa tabeller och använda databasen utan att behöva skriva SQL -kod. I slutet ska drivrutinsinstallationen ge oss följande meddelande i vår konsol.

Anslut till en databas

Eftersom vi har beroenden installerade, är det vi måste göra nu att testa hur vår nya data -persistensmiljö fungerar, för detta kommer vi att skapa en klass. Denna klass kommer att vara grunden som gör att vi kan skapa en tabell och lagra poster i den, detta ger oss också möjlighet att slippa skriva kod SQL direkt, så att i framtiden när vi måste använda en annan databasmotor är det bara att ändra konfigurationen.

I vår applikationsmapp ska vi skapa en fil som heter låtar.rb, vad den här klassen måste göra är att ha kartan över hur vi kan lagra en låt i databasen, låt oss se innehållet och sedan förklara vad varje avsnitt av det gör:

 kräver 'dm-core' kräver 'dm-migrations' DataMapper.setup (: default, "sqlite3: // # {Dir.pwd} /musica.db") klasslåtar inkluderar DataMapper :: Resource property: id, Serial property: title, String property: duration, Integer property: release_date, Date end DataMapper.finalize

Först och främst måste vi göra behöva av de viktigaste komponenterna i DataMapper I detta fall dm-core Y dm-migreringar. Sedan skapar vi en konfigurationsrad som är den som tillåter oss att använda i första hand SQLite att omedelbart skapa filen, i det här fallet musik.dbOm filen redan finns betyder det att databasen redan finns, så anslutningen skulle helt enkelt göras.

Vi gör äntligen vår klass låtar som kommer att innehålla en serie attribut som identifierar det och införandet av en annan klass av DataMapper. Med detta är vi redo för nästa fas, som är att testa vår applikation. Eftersom vi inte har skapat något att se i vår webbläsare är det en bra tid att använda Rubin interaktiv konsol (irb), som gör att vi kan kontrollera att allt är på rätt spår, förutom att vi kan vänja oss vid DataMapper.

Prova vår app

Först och främst i vår terminal eller konsol måste vi gå till mappen där vi har lagrat vår fil låtar.rb eftersom det här är nyckeln för att utveckla vårt exempel måste vi väl starta vår interaktiva konsol där Rubin genom att skriva kommandot:

 irb

När vi väl startat det kan vi göra det behöva i vår klass genom att placera kommandot:

 kräver "./sånger"

Detta måste återvända sant om det lyckas, vilket vi kan se i följande bild.

Nästa akt måste vi använda verktyget auto_migrera av DataMapper, detta gör att vi kan skapa tabellen med attributen för vår klass i motsvarande databasfil. För detta skriver vi helt enkelt följande:

 Songs.auto_migrate!

Vilket skapar den nödvändiga strukturen för att kunna lagra posterna.

Skapa vår första låt

Vad vi nu måste göra är att skapa det objekt som gör att vi kan lagra de nödvändiga värdena i databasen, för detta kommer vi att skapa ett objekt som heter song:

 song = Songs.ny

För att senare lagra det med följande kommando:

Detta ger oss redan en basplattform för att inkludera informationen i vår databas, låt oss se vad konsolen ska visa vid denna tidpunkt:

När detta är gjort kan vi lagra data för det. Medan vi fortfarande är i vår konsol kommer vi att lägga till attributen för vårt objekt en efter en, låt oss se:

 song.title = “Ny låt” song.duration = “315” song.release_date = Date.new (2010) song.save

Var och en av de tidigare instruktionerna lagrades i låtobjektet och körde metoden spara allt detta lagras i databasen. Vi ser i följande bild processen som vi har genomfört.

Det noterar vi också Rubin det är skiftlägeskänsliga så vi måste vara försiktiga med hur vi skriver våra klasser, eftersom det var ett fel när det gällde konsolen när vi skrev klassen Datum, sedan Datum skrevs, vilket upptäcktes omedelbart. Slutligen, om vi vill konsultera de lagrade låtarna är det tillräckligt att skriva följande instruktion:

 Songs.all

Vi kan också redogöra för hur många poster vi har med följande.

 Låtar. Räkna

För att avsluta, låt oss se svaret som mottogs i vår konsol när vi utför dessa två kommandon.

Vi har infogat vår första post och har konsulterat den framgångsrikt och därmed lärt oss hur vi använder databasen med Sinatra, även om de mest observanta kan ha insett att allt vi gjorde var i Rubin, och detta var den fantastiska idén, för att visa hur man vet Rubin vi kan arbeta med Sinatra utan att ha många komplikationer.