Herziening van softwaretools voor het maken van databases. Hoe maak ik een database voor mijn applicaties
Zoals hierboven vermeld, correct gebruik gespecialiseerde componenten plaatsen ze qua prestaties vrijwel op hetzelfde niveau als API-aanroepen van de geselecteerde DBMS. Naar mijn mening, API-gebruik daarin gerechtvaardigd in een zeldzaam geval, wanneer de mogelijkheden van zelfs specifieke componenten voor ontwikkeling onvoldoende zijn, hoewel dit uiterst onwaarschijnlijk is, of als dergelijke componenten niet beschikbaar zijn voor het platform waarvoor ontwikkeling wordt uitgevoerd (Sun Solaris). Query's maken naar de database. Nadat we een strategie voor gegevenstoegang hebben gekozen en de applicatiearchitectuur hebben bepaald, kunnen we onze aandacht richten op de manier waarop we deze gaan gebruiken. De hoofdregel is dat hoe minder data u opvraagt bij de server, hoe sneller uw applicatie zal draaien. Het is natuurlijk irrationeel om de server om minder gegevens te vragen dan de gebruiker in één keer wil zien, dus de eerste vraag zou moeten zijn: “welke gegevens zijn nodig voor elke module van het systeem?” Ontwikkelaars die overstappen van desktopdatabases moeten het tabellarische overwinnen georiënteerde blik over databanken. De InterBase-database bevat ongetwijfeld tabellen. Maar als je een programma ontwerpt, zie je ze niet, je ziet alleen het resultaat van het uitvoeren van de SQL-query. U kunt uiteraard een query schrijven die alle records uit de tabel retourneert (door ten minste zichtbaar voor deze transactie):
SELECTEER * UIT SOMMIGE_TABEL
Maar in de meeste gevallen levert een dergelijke zoekopdracht aanzienlijk meer gegevens op dan nodig is optimale prestaties gebruikersinterface en bedrijfsprocesverwerking. Gelijkaardig verzoek gebruikt dit trouwens niet handige functies InterBase/Firebird, als de mogelijkheid om de resulterende dataset samen te voegen (JOIN) en te sorteren (ORDER BY).
Vraag minder gegevens aan – ontvang deze hogere snelheid. Mogelijk hebt u niet alle kolommen van de tabel nodig om bepaalde taken in uw programma uit te voeren. In feite zou u niet vaak het teken "*" moeten gebruiken bij selectiequery's; het is beter om een directe opsomming van velden te gebruiken. Deze methode is gebaseerd op het feit dat zelfs als ik alle kolommen van de tabel nodig heb, ik niet de tabelkolommen nodig heb die in de toekomst zullen worden toegevoegd wanneer ik dit deel van het programma voltooi. Het definiëren van specifieke kolommen in de query zorgt ervoor dat ik alleen de kolommen krijg die ik in de query heb gedeclareerd, zelfs als de tabelstructuur verder evolueert. Op dezelfde manier hoeft een gebruiker, zelfs als hij echt elke rij in een tabel nodig heeft, ze niet allemaal op een bepaald moment te zien. Het kan voor een gebruiker uiterst lastig zijn om velden te zoeken in het midden van een gegevensraster in een tabel met een hoger dan gemiddeld aantal records. Stel dat u meer dan 100 records in uw tabel heeft, dan moet u al goed nadenken over het ontwerp van uw toepassing.
Waar komt dit allemaal op neer? Dit is wat: hoe minder gegevens u opvraagt en verzendt, hoe sneller uw applicatie werkt, zelfs bij lage snelheden. hogesnelheidsnetwerken. Hier volgen enkele praktische technieken die u kunt gebruiken om de hoeveelheid gegevens die u selecteert te verminderen.
Geef de gebruiker goede hulpmiddelen om te zoeken naar records die hem interesseren. Als de lijst te groot is om in één aaneengesloten vorm weer te geven, verdeel deze dan in logische pagina's, gerangschikt op de eerste letter van A tot Z. Als de lijsten in dit geval te lang zijn, voorzie de gebruiker dan van krachtige tools voor gegevensfiltering om de resulterende set records te beperken. Om het zoeken naar gegevens in de applicatie te implementeren, kunt u de methoden gebruiken die worden gebruikt om webpagina's te doorzoeken. Wanneer de gebruiker een set records krijgt, zelfs als deze relatief klein is, is het voldoende om een of twee sleutelvelden te gebruiken om een zoekfilter te vormen. Laat het in de applicatie staan apart raam of een deel van het venster waar de gebruiker alle gegevens voor een record kan zien als hij heeft gevonden wat hij zocht. Probeer waar mogelijk ook table joins (JOIN) te gebruiken in query's in plaats van opzoekvelden op formulieren. Hoewel het mogelijk is om de uitvoering van de TDataset. Kijk, zelfs deze verbeterde methode zal niet sneller werken dan het samenvoegen van tabellen (JOIN) - u hoeft het werk van de ongewijzigde methode helemaal niet te vermelden.
Afdeling Toegepaste Informatica
Toelichting bij het cursuswerk
per vakgebied:
“Databases”
“Ontwikkeling van databases en clientapplicaties”
Kaluga 2009
Invoering
1. Verklaring van het probleem
2.Ontwerp, creatie en beheer van de database
3.Technologische gebruiksinstructies
Conclusie
Lijst met gebruikte literatuur
Invoering
Het doel van mijn cursuswerk is het bouwen van een database en het bestuderen van de basiselementen SQL-taal, evenals het verwerven van praktische vaardigheden bij het maken van een eenvoudige database.
De relevantie van het cursuswerk wordt gedefinieerd als de noodzaak om databases te creëren en te ontwerpen.
In de moderne wereld is er een grote verscheidenheid aan databases. Zonder welke de eeuw informatietechnologie zou niet kunnen bestaan en zich geleidelijk kunnen ontwikkelen. Moderne wereld kunnen niet zonder gestructureerde en gesorteerde informatie, databases maken dit mogelijk. Databases zijn nodig voor veel gebieden van menselijke activiteit, of het nu gaat om bankieren, boodschappen doen of het bijhouden van huishoudelijke uitgaven.
Bij elke stap worden databases gevonden. Bijna elk systeem is een goedgebouwde database, bijvoorbeeld de bekende “Consultant +” of enkele belastingboekhouding bij het Ministerie van Belastingen en Heffingen.
Mijn database is ontworpen om activiteiten te automatiseren en betrouwbare en tijdige informatie te verkrijgen.
De doelstellingen van het cursuswerk zijn als volgt:
Implementeer een database;
Implementeren gebruikersinterface;
Opstellen van rapporten;
Momenteel veel moderne talen programmeren, databaseprogrammering ondersteunen, met behulp van dergelijke talen kunt u creëren noodzakelijke basis gegevens, of deze nu eenvoudig of uiterst complex zijn.
1. Verklaring van het probleem
De ontwikkelde database bestaat uit verschillende “niveaus”. Het meest abstracte ‘niveau’ is het dataschema. Op dit niveau worden relaties tussen tabellen direct weergegeven.
In dit cursuswerk zijn de taken vastgelegd:
Een fysiek model bouwen op een computer (met Erwin);
Definitie van verbindingen, datatypen;
Ontwikkeling van een handige gebruikersinterface;
Aanmaken van aanvragen, formulieren;
Maken van rapporten (zoals toegewezen);
Het bouwen van het hoofdknopformulier;
In mijn cursuswerk is een fragment van een personeelsboekhoudsysteem gemaakt. Daarom bestaat de boekhouding uit de volgende bewerkingen:
In mijn cursuswerk is in dit opzicht een fragment van een productboekhoudsysteem gemaakt; de boekhouding bestaat uit de volgende bewerkingen:
Goederenboekhouding;
Boekhouding van goederen per groep;
Boekhouding van goederen via ontvangstbewijzen;
Dit systeem is ontworpen om deze handelingen te automatiseren, betrouwbare en tijdige informatie te verkrijgen en outputdocumenten te genereren.
2. Ontwerp, creatie en beheer van de database
De database bevat 4 tabellen.
1) De tabel Productgroepen bevat 2 kolommen Productgroepnummer en Productgroepnaam.
2) De producttabel bevat 4 kolommen: Product_Number, Productnaam, Prijs, Productgroepnummer.
3) De controletabel bevat 2 kolommen: Controlenummer, Datum.
4) De tabel Product per kassabon bevat 3 kolommen: Productnummer, Ontvangstnummer. Hoeveelheid.
Om het werken met de database te vergemakkelijken, zijn er verschillende formulieren gemaakt.
Het doel van formulieren is zeer divers; formulieren kunnen worden gebruikt om zoekopdrachten, tabellen weer te geven, het gemak van opname in tabellen, enz.
Formulieren aanvragen.
1) Aanvraagformulier 1 (zie afb. 1)
Het is noodzakelijk om de goederen terug te nemen met behulp van een specifiek ontvangstnummer. Dit formulier presenteert gebruiksvriendelijke interface om informatie in te voeren, evenals handig bekijken rapport.
Rijst. 1 Aanvraagformulier1
Bijvoorbeeld. Voer het chequenummer – 7 – in het tekstvak in en klik op de knop – Bekijk rapport (zie figuur 2).
Rijst. 2 Rapportagebewerking1
2)Aanvraagformulier2
Artikelen moeten op datum worden weergegeven. Dit formulier biedt een handige interface voor het invoeren van informatie en het gemakkelijk bekijken van het rapport.
Rijst. 3 Aanvraagformulier2
Bijvoorbeeld. Voer de datum – 11/12/08 – in het tekstvak in en klik op de knop – Bekijk rapport. (zie afbeelding 4)
Rijst. 4 Vraag werk aan2
De organisatie van de gegevensinvoer in tabellen vindt plaats via geschikte formulieren. Voor het gemak is er een hoofdknopformulier gemaakt. (zie afb. 5)
Dit formulier ziet er als volgt uit:
Rijst. 5 Knopvorm
Het hoofdmenu bevindt zich hier. Elke knop geeft toegang tot rapporten; als u erop klikt, kunt u de rapporten heel eenvoudig bekijken.
Het submenu Tabellen bevat tabellen waarin u informatie in een handige vorm kunt invoeren.
Gegevensdiagram (zie Fig. 6
Rijst. 6 Gegevensschema
Het dataschema is gemaakt met behulp van Erwin-software.
3. Technologische gebruiksinstructies
Bijvoorbeeld:
- Binnenkomen nieuw product.
Om een nieuw product te introduceren, moet u de volgende stappen uitvoeren (zie Afb. 7):
Ga naar het hoofdknopformulier -> klik op de tabelknop -> klik op de productknop -> voer de naam van het product en de prijs in en selecteer tot welke productgroep het behoort.
Rijst. 7 Een nieuwe medewerker onboarden
Indien in de lijst met productgroepen de gewenste groep Anders voeren we het handmatig in
Klik op de knop Productgroep -> en voer een nieuwe productgroep in. (zie afbeelding 8)
Afb. 8. Schepping nieuwe groep goederen.
-> selecteert tevens het nummer van de kassabon waar dit product doorheen gaat -> voer het aantal van dit product in. (zie afbeelding 10)
Conclusie
De doelstellingen van de cursus zijn volledig bereikt. Er werd een database ontwikkeld om goederen te registreren. Het cursuswerk is gemaakt in MS Access. Het datadiagram (fysiek model) is gebouwd in het Erwin-programma. Er is ook een gebruiksvriendelijke gebruikersinterface geïmplementeerd voor veilige en gemakkelijke invoer van informatie. Met dit werk zijn ook de taken voltooid die aan het begin van het cursuswerk waren gesteld, alle problemen zijn opgelost en hun oplossingen kunnen direct in het cursuswerk worden bekeken.
Heb dit ontwikkeld cursus werk, Ik realiseerde me dat het DBMS Microsoft-toegang krachtig en handig hulpmiddel om databanken te creëren. Een grafische interface met meerdere vensters waarmee ik interactief tabellen, formulieren, query's en rapporten kan maken. Speciale apparaten die het werk automatiseren tijdens het maken en onderhouden van een database (Masters en Designers, Assistants, etc.) vereenvoudigen het hele proces aanzienlijk en maken het programma voor iedereen toegankelijk om te studeren.
Ik geloof dat dergelijke vaardigheden, zelfs de basisvaardigheden, in mijn beroep in de loop van de tijd zeer nuttig voor mij zullen zijn.
Het was ook erg interessant en handig om in MS Access te werken, formulieren te maken, met hulp te werken, boeken over databases en MS Access in het bijzonder te bekijken en te bestuderen. Ik heb ongetwijfeld kennis kunnen maken met zo'n geweldig programma als Erwin, dat helpt om het maken van databases snel en beter te begrijpen. Zeker, moderne bases Er komen elke dag steeds meer gegevens bij die voldoen aan de behoeften van gebruikers. Daarom ontstaat het probleem hoe u dergelijke databases kunt maken, hoe u ze kunt beheren... Na het lezen en analyseren van dit cursuswerk kunt u ongetwijfeld basisvaardigheden opdoen in het bouwen databases.
Lijst met gebruikte literatuur
1. Microsoft Access 2000. Stap voor stap: Praktisch. toelage / Per. uit het Engels
M.: Uitgeverij EKOM, 2002. - 352 pp.: ill.
2. Handleiding: Toegang tot kantoor 2003. - Sint-Petersburg: Peter, 2004. - 464 p.: ill.
3. Databases. Ontwerp, implementatie en ondersteuning. Theorie en
oefening. 3e editie. : Per. uit het Engels - M.: Uitgeverij "William",
2003. - 1440 blz. : ziek. - Paraal. mees. Engels
- Handleiding
- Herstelmodus
Hallo allemaal! Mijn naam is Oleg en ik ben een amateur-Android-programmeur. Amateuristisch omdat op dit moment Ik verdien geld door in een heel andere richting te programmeren. En dit is een hobby waaraan ik mijn wijd vrije tijd. Helaas ken ik geen Android-programmeurs en haal ik al mijn basiskennis uit boeken of van internet. In alle boeken en artikelen op internet die ik lees, besteedt het maken van een database voor een applicatie heel weinig ruimte en in feite komt de hele beschrijving neer op het creëren van een klasse die een erfgenaam is SQLiteOpenHelper en daaropvolgende SQL-injectie coderen Java-code. Afgezien van het feit dat we slecht leesbare code krijgen (en als er meer dan 10 tabellen in onze applicatie verschijnen, dan is het onthouden van al deze relaties tussen tabellen een hel), dan kunnen we in principe natuurlijk leven, maar op de een of andere manier willen we niet naar.
Ik vergat het belangrijkste te zeggen, je kunt zeggen dat dit mijn eerste poging is om hier te schrijven. En dus laten we gaan.
Over de eeuwige vraag: waarom?
Om eerlijk te zijn, weet ik eerlijk gezegd niet waarom boeken en artikelen over programmeren voor Android geen tools beschrijven voor het ontwerpen van databasearchitectuur en enkele patronen voor het werken met databases in de fase van hun creatie. Het lijkt gemakkelijk om slechts een paar pagina's aan een boek toe te voegen of een apart artikel te schrijven (zoals ik nu doe) - maar nee. In dit artikel zal ik kort de tools doornemen die ik in mijn werk gebruik en meer in detail over de code die verantwoordelijk is voor de initiële creatie van de database, die er vanuit mijn oogpunt leesbaarder en handiger uitziet.
Als onze applicatie meer dan 5 tabellen heeft, dan zou het geen slecht idee zijn om er een tool voor te gebruiken visueel ontwerp database-architectuur. Omdat dit voor mij een hobby is, gebruik ik het absoluut. gratis hulpmiddel genaamd Oracle SQL Developer Data Modeler (u kunt het downloaden).
Dit programma Hiermee kunt u tabellen visueel tekenen en er relaties mee opbouwen. Met deze ontwerpaanpak kunnen veel ontwerpfouten in de databasearchitectuur worden vermeden (ik vertel je dit al als professionele databaseprogrammeur). Het ziet er ongeveer zo uit:
Nadat we de architectuur zelf hebben ontworpen, gaan we verder met het meer vervelende deel, dat bestaat uit het maken van SQL-code om tabellen te maken. Om dit probleem te helpen, gebruik ik al een tool genaamd SQLiteStudio (die op zijn beurt hier kan worden gedownload).
Dit hulpmiddel is een analoog van bekende producten als SQL Naviagator, Toad enz. Maar zoals de naam al doet vermoeden, is het ontworpen om met SQLite te werken. Hiermee kunt u visueel een database maken en DDL-code verkrijgen tabellen gemaakt. Je kunt er overigens ook Views mee aanmaken, die je desgewenst ook in je applicatie kunt gebruiken. Ik weet niet hoeveel de juiste aanpak met behulp van views in Android-programma's, maar in een van mijn applicaties gebruikte ik ze.
Sterker nog, ik gebruik geen tools van derden meer, en dan begint de magie Android-studio. Zoals ik hierboven schreef: als we SQL-code in Java-code gaan implementeren, is de uitvoer die we krijgen slecht leesbare en daarom slecht uitbreidbare code. Daarom heb ik alle SQL-instructies erin geplaatst externe bestanden, die ik in de directory heb activa. In Android Studio ziet het er ongeveer zo uit:
Over de db- en datamappen
Binnen de map activa Ik heb twee mappen gemaakt db_01 En gegevens_01. De nummers in de directorynamen komen overeen met het versienummer van mijn database waarmee ik werk. In de map db Ik bewaar ze zelf SQL-scripts tabellen maken. En in de map gegevens De gegevens die nodig zijn voor de eerste vulling van tabellen worden opgeslagen.
Laten we nu eens kijken naar de code in mijn DBHelper die ik gebruik in mijn projecten. In eerste instantie klasse variabelen en de constructor (geen verrassingen hier):
Privé statische finale String TAG = "RoadMap4.DBHelper";
Tekenreeks mDb = "db_"; Tekenreeks mData = "data_"; Context mContext;
int mVersie;
en hier wordt het interessanter:
@Override public void onCreate(SQLiteDatabase db) ( ArrayList
AssetManager assetManager = mContext.getAssets(); String dir = mDb + mVersie; try ( String listFiles = assetManager.list(dir); for (String bestand: listFiles)( files.add(file); ) Collections.sort(files, new QueryFilesComparator()); BufferedReader bufferedReader; String query; String line; for (String bestand: bestanden)( Log.d(TAG, "bestand db is " + bestand); bufferedReader = new BufferedReader(nieuwe InputStreamReader(assetManager.open(dir + "/" + bestand))); query = ""; while ((line = bufferedReader.readLine()) != null)( query = query + line; ) bufferedReader.close(); tabellen.add(query) ) catch (IOException e) ( e.printStackTrace(); ) return tafels;
)
in een bepaalde volgorde . Ik gebruik nummering in de namen van de bestanden en met behulp daarvan sorteer ik. Privéklasse QueryFilesComparator implementeert Comparator
( @Overschrijf public int Compare(String file1, String file2) ( Integer f2 = Integer.parseInt(file1.substring(0, 2)); Integer f1 = Integer.parseInt(file2.substring(0, 2)); return f2 .vergelijkTo(f1);
Het invullen van de tabellen maakt het steeds leuker. Mijn tafels zijn niet alleen strak gevuld
gegeven waarden
, maar ook waarden uit bronnen en UUID-sleutels (ik hoop ooit tot een netwerkversie van mijn programma te komen zodat mijn gebruikers met gedeelde gegevens kunnen werken). De structuur van de bestanden met de initiële gegevens ziet er als volgt uit:
Ondanks het feit dat mijn bestanden de sql-extensie hebben, zit er geen sql-code in, maar zoiets als dit:
Prioriteiten
pri_id:UUID:UUID
gegeven waarden
pri_name:string:normaal
pri_color:kleur:kleurgroen
pri_default:int:1
prioriteiten
pri_id:UUID:UUID
gegeven waarden
pri_name:string:normaal
pri_object:string:object_taak
pri_name:string:vasthouden
prioriteiten
pri_id:UUID:UUID
gegeven waarden
, maar ook waarden uit bronnen en UUID-sleutels (ik hoop ooit tot een netwerkversie van mijn programma te komen zodat mijn gebruikers met gedeelde gegevens kunnen werken). De structuur van de bestanden met de initiële gegevens ziet er als volgt uit:
Ondanks het feit dat mijn bestanden de sql-extensie hebben, zit er geen sql-code in, maar zoiets als dit:
Prioriteiten
pri_id:UUID:UUID
gegeven waarden
pri_color:kleur:kleurBlauw
pri_color:kleur:kleurgroen
pri_default:int:1
prioriteiten
pri_id:UUID:UUID
gegeven waarden
pri_color:kleur:kleurBlauw
pri_object:string:object_taak
pri_name:string:vasthouden
prioriteiten
pri_default:int:0 pri_name:string:belangrijk in relatie tot een regel en als ik krijg dat de grootte ervan 1 is, dan betekent dit de naam van de tabel waarin de gegevens moeten worden geschreven. Anders zijn het de gegevens zelf. Het eerste veld is de naam van het veld in de tabel. Het tweede veld is het type waarmee ik bepaal wat ik in dit veld moet schrijven. Als het een UUID is, betekent dit dat ik een unieke UUID-waarde moet genereren. Als string betekent dat ik een stringwaarde uit de bronnen moet extraheren. Als kleur, dan moet je opnieuw de kleurcode uit de bronnen halen. Als int of tekst, dan converteer ik deze waarde eenvoudig naar int of String zonder enige fysieke beweging. De code zelf ziet er als volgt uit:
@Override public void onCreate(SQLiteDatabase db) ( ArrayList
try ( String listFiles = assetManager.list(dir); for (String bestand: listFiles)( files.add(file); ) Collections.sort(files, new QueryFilesComparator()); BufferedReader bufferedReader; String line; int separator = 0 ; ContentValues cv = null; String naamTabel = null; String pakketNaam = mContext.getPackageName(); Hm; for (String file: files)( Log.d(TAG, "file db is " + file); bufferedReader = new BufferedReader(new InputStreamReader(assetManager.open(dir + "/" + file))); while ((line = bufferedReader.readLine()) != null)( velden = line.trim().split("); if (fields.length == 1)( if (flag == true)( hm = nieuwe HashMap
Laten we hiervoor een lege Windows-applicatie maken. Omgeving uiterlijk
De ontwikkeling wordt weergegeven in Figuur 39.
Rijst. 39. Blanco aanvraag
Figuur 39 benadrukt de componentgroep “Gegevens”, die componenten bevat voor toegang tot en manipulatie van gegevens.
Het binden van databasegegevens aan het formulier wordt uitgevoerd door de component “Binding Source”. Laten we het overbrengen naar het formulier. Nadat het op het formulier is geplaatst, ziet de ontwikkelomgeving er als volgt uit (Afb. 40).
Rijst. 40. Bindende broncomponent op het formulier
De component is niet visueel en wordt daarom in een extra paneel weergegeven. De belangrijkste eigenschap van de component is de eigenschap DataSource, die naar de gegevensbron verwijst. Standaard is de eigenschap leeg, dus u moet de waarde ervan configureren. Bij het kiezen van dit pand Het volgende venster verschijnt in het eigenschappenvenster (Afb. 41).
Rijst. 41. Lijst met gegevensbronnen
De lijst is momenteel leeg, dus u moet een nieuwe gegevensbron maken door de opdracht Projectgegevensbron toevoegen te selecteren om een nieuwe gegevensbron te maken en er verbinding mee te maken. Het volgende dialoogvenster verschijnt (Afb. 42).
Rijst. 42. Lijst met gegevensbronnen
Dit dialoogvenster biedt de volgende keuze aan gegevensbronnen:
Database - Database;
Dienst - Een dienst is een dienst die gegevens levert. Meestal is dit een webservice;
Object - Object voor het selecteren van een object dat gegevens genereert en objecten om ermee te werken.
In ons geval moet u het item “Database” selecteren. Er verschijnt een venster voor het selecteren van een dataverbinding (Afb. 43).
Rijst. 43. Een dataverbinding selecteren
Het doel van dit dialoogvenster is het maken van een verbindingsreeks die de verbindingsparameters voor de ADO-engine beschrijft, zoals het databasetype, de locatie, gebruikersnamen, beveiligingsfuncties, enz.
De vervolgkeuzelijst van het dialoogvenster bevat alle eerder gemaakte verbindingen. Als de gewenste verbinding niet in de lijst staat, gebruikt u de knop “Nieuwe verbinding”. Als u op de knop drukt, verschijnt het volgende dialoogvenster (Afb. 44).
Selecteer in dit dialoogvenster het type gegevensbron (in in dit geval Microsoft Access), de databasenaam (in dit geval de naam en locatie van het databasebestand) en de gebruikersnaam en het wachtwoord die worden gebruikt om verbinding te maken met de database. Met de knop "Geavanceerd" kunt u een groot aantal parameters instellen die betrekking hebben op verschillende delen van de ADO-engine. Als u de knop “Testverbinding” gebruikt, zorgt u ervoor dat de ingevoerde parameters correct zijn en dat de verbinding werkt.
Rijst. 44. Een nieuwe verbinding maken
De laatste stap van het dialoogvenster is het selecteren van de tabellen of andere databaseobjecten die nodig zijn deze bron gegevens. Het selectievenster wordt getoond in Figuur 45.
Rijst. 45. Selecteren van de benodigde tabellen
In dit venster zijn de tabellen “Toeristen” en “Toeristische Informatie” geselecteerd. Omdat er geen andere objecten dan tabellen in de database zijn gemaakt, worden in Afbeelding 45 alleen tabellen weergegeven. Hiermee is het maken van de gegevensbron voltooid. Nadat u op de knop “Voltooien” hebt geklikt, verschijnt er een DataSet-component op het formulier naast de BindingSource-component.
Nu moeten de hierboven verbonden gegevens op het formulier worden weergegeven. De eenvoudigste manier om gegevens weer te geven is door de component DataGridView uit de componentgroep Gegevens te gebruiken. De component is visueel en ziet er zo uit op het formulier (Afb. 46).
Rijst. 46. DataGridView-component
Het venster met componentinstellingen verschijnt onmiddellijk, waarin de mogelijkheden voor gegevensbewerking worden bepaald: "Toevoegen inschakelen", "Bewerken inschakelen", "Verwijderen inschakelen"; de mogelijkheid om de volgorde van kolommen te wijzigen: “Schakel de mogelijkheid in om de volgorde van kolommen te wijzigen” (“Herschikking van kolommen inschakelen”); evenals de mogelijkheid om aan de oudercontainer te worden bevestigd.
Om ervoor te zorgen dat de component gegevens weergeeft, moet u een gegevensbron selecteren in de vervolgkeuzelijst. Als u de vervolgkeuzelijst selecteert, verschijnt het volgende dialoogvenster (Afb. 47).
Rijst. 47. Een gegevensbron selecteren voor DataGridView
In dit geval hebben we de tabel “Toeristen” als gegevensbron gekozen. Deze selectie verandert de schermvorm als volgt (Fig. 48).
Rijst. 48. De component DataGridView geeft de tabelstructuur weer
De figuur laat zien dat er nog een BindingSource-component en een TableAdapter-component zijn verschenen, die werken met de tabel “Toeristen”. Houd er rekening mee dat tijdens de ontwerpfase of tijdens het ontwikkelingsproces de gegevens uit de tabel niet worden weergegeven.
Nu moet u de gegevens uit de gekoppelde tabel “Toeristische Informatie” weergeven. Om dit te doen, plaatst u een andere DataGridView-component op het formulier en selecteert u het volgende als gegevensbron (Afb. 49).
Rijst. 49. Een gegevensbron selecteren voor de tweede DataGridView
Hier is de gegevensbron niet de tabel “Toeristeninformatie” zelf, maar de verbinding (Binding Source) tussen de tabellen “Toeristen” en “Toeristeninformatie”. Deze keuze zorgt ervoor dat alleen de rijen die aan de tabel “Toeristische Informatie” zijn gekoppeld, worden geselecteerd. huidige lijn in de tabel "Toeristen". Deze keuze zorgt er ook voor dat bijbehorende gegevens correct worden bijgewerkt en verwijderd. De werking van de resulterende toepassing wordt getoond in Figuur 50.
Rijst. 50. Databaseapplicatie op het werk
Navigeren door gegevens met behulp van de pijltjestoetsen is lastig. Om de gegevensnavigatie te vereenvoudigen is er een BindingNavigator-component. Laten we het op het formulier plaatsen (Fig. 51).
Rijst. 51. BindingNavigator-component op het formulier
Met dit onderdeel kunt u tussen tabelrecords navigeren en tabelrijen toevoegen en verwijderen. De functionaliteit en het uiterlijk van de component kunnen worden aangepast omdat het een ToolStripContainer-menustrook is.
De eigenschap die bepaalt via welke tabel de navigatie wordt uitgevoerd, is de eigenschap BindingSource. Laten we de waarde van deze eigenschap instellen op "toeristenBindingSource". In bedrijf ziet het onderdeel er als volgt uit (Afb. 52).
Rijst. 52. BindingNavigator-component aan het werk
Het bewerken van gegevens in de cellen van de DataGridView-component met de juiste instellingen is mogelijk, maar het is lastig en niet rationeel. Met name is het lastig ingevoerde waarden te controleren op fouten. Daarom zullen we voor de tabel “Toeristen” een schermformulier maken waarmee u gegevens in TextBox-componenten kunt weergeven en bewerken. Om dit te doen, plaatst u een container van het type Panel op het formulier en daarop drie TextBox-componenten, als volgt (Afb. 53).
Rijst. 53. Schermpaneel voor het bewerken van gegevens in de tabel “Toeristen”.
Nu moet u de TextBox-componenten aan de overeenkomstige velden van de tabel “Toeristen” binden. Om dit te doen gebruiken we de eigenschap uit de groep DataBindings - Geavanceerd, weergegeven in Figuur 54.
Rijst. 54. Eigenschap “DataBindings - Geavanceerd”
Als u deze eigenschap selecteert, verschijnt het dialoogvenster dat wordt weergegeven in Afbeelding 55. Met dit dialoogvenster kunt u niet alleen gegevens binden, maar ook een gebeurtenis instellen waarbinnen de gegevens worden bijgewerkt, en de gegevens formatteren bij het uitvoeren ervan.
Voor de bovenste TextBox-component selecteert u in de vervolgkeuzelijst Binding “toeristenBmdmgSource” als gegevensbron en het bronveld als “Achternaam”. Voor de middelste en onderste TextBox-componenten selecteert u dezelfde gegevensbron en respectievelijk de velden "Naam" en "Patroniem".
De ontwikkelde applicatie ziet er in gebruik als volgt uit (Fig. 56).
Rijst. 55. Dialoogvenster voor de eigenschap “DataBindings - Geavanceerd”.
Rijst. 56. Gegevensbinding aan visuele componenten
Wanneer er echter wijzigingen worden aangebracht, blijven alle nieuwe gegevens alleen op het formulier staan. Ze worden niet in de database opgeslagen en als de applicatie opnieuw wordt aangeroepen, zijn ze uiteraard verdwenen. Dit gebeurt omdat de gegevens zijn geladen in een DataSet-object, dat een kopie in het geheugen van de tabel is. Met deze kopie worden alle acties uitgevoerd. Om wijzigingen in de database weer te geven, moet u de Update-methode van de TableAdapter-klasse uitvoeren. In de applicatie die wordt ontwikkeld, is het dus noodzakelijk om de knop "Update" te plaatsen en de volgende programmacode in de Click-gebeurtenishandler te schrijven:
toeristenTableAdapterUpdate(bDTur_firmDataSet); information_about_touristsTableAdapter.Update(bDTur_firmDataSet);
Deze code werkt de informatie bij in de tabellen Toeristen en Toeristeninformatie die door de gegevensbron worden geleverd. Houd er rekening mee dat deze methode overbelast is en dat u met de varianten ervan zowel een individuele tabelrij als een groep rijen kunt bijwerken.
Delphi is een ontwikkelomgeving die de taal gebruikt Delphi-programmering(vanaf versie 7 heet de taal in de omgeving Delphi, voorheen Object Pascal), ontwikkeld door Borland en aanvankelijk geïmplementeerd in zijn Borland Delphi-pakket, waarvan het in 2003 zijn huidige naam kreeg. Object Pascal is in wezen een opvolger Pascal-taal met objectgeoriënteerde extensies.
Delphi is het optimale hulpmiddel voor het maken van databasetoepassingen. Optimaal, omdat ondersteunt visuele ontwikkelingstechnologie, die de ontwikkeltijd aanzienlijk kan verkorten en tegelijkertijd behouden blijft goede kwaliteit en betrouwbaarheid softwareproduct. Dankzij de taalstructuur van Delphi kunt u verborgen fouten vermijden.
Kenmerken van de Delphi 7-familie:
*Woensdag snelle ontwikkeling applicaties, waarin tools zijn geïntegreerd voor het modelleren van de ontwikkeling en implementatie van e-commerceapplicaties en webservices.
*Ondersteuning voor programmeertalen voor Win32 (Delphi en C/C++) en voor .NET (Delphi en C#) in één enkele ontwikkelomgeving, waardoor het gemakkelijker wordt om nieuwe Win32-applicaties te onderhouden en te creëren en .NET-technologieën gemakkelijker onder de knie te krijgen;
*De mogelijkheid voor zowel traditionele Windows- als Java-ontwikkelaars om .NET-applicaties te ontwikkelen zonder de tools die ze gebruiken op te geven, met behoud van dezelfde vaardigheden en het gebruik van vergelijkbare programmeerconcepten;
*Het nieuwe systeem van codesjablonen en andere innovaties in de ontwikkelomgeving verbeteren het werken met broncodes kwalitatief en verhogen de ontwikkelingsproductiviteit;
Microsoft SQL-server 2000 is een compleet aanbod op het gebied van databases en data-analyse voor snelle creatie schaalbare e-commerceoplossingen, bedrijfsapplicaties en datawarehouses.
Het verkort de time-to-market voor deze oplossingen aanzienlijk en biedt tegelijkertijd schaalbaarheid om aan de meest veeleisende vereisten te voldoen.
Het Delphi-pakket is een voortzetting van Borland Corporation's lijn van Pascal-taalcompilers. Pascal als taal is heel eenvoudig, en een strikte controle van het gegevenstype helpt fouten vroegtijdig op te sporen en stelt u in staat snel betrouwbare en efficiënte programma's te maken.
Het ontwikkelen van databaseapplicaties is een van de meest gewilde mogelijkheden van de Delphi-programmeeromgeving. De kracht en flexibiliteit van Delphi bij het werken met databases is gebaseerd op een kern op laag niveau: de Borland-databaseprocessor Database-engine(BDE). De interface met applicatieprogramma's genaamd Integrated Database Application Programming Interface (IDAPI). Met BDE kunt u toegang krijgen tot gegevens met behulp van zowel de traditionele recordgeoriënteerde (navigatie)benadering als de setgeoriënteerde benadering die wordt gebruikt in SQL-databaseservers.
De objectbibliotheek bevat een set visuele componenten, waardoor de ontwikkeling van applicaties voor DBMS met client-server-architectuur aanzienlijk wordt vereenvoudigd. Objecten kapselen zichzelf in lager niveau- Borland-database-engine.
Er zijn speciale sets componenten die verantwoordelijk zijn voor toegang tot gegevens en componenten die gegevens weergeven. Met componenten voor gegevenstoegang kunt u verbinding maken met de database, gegevens ophalen, kopiëren, enz.
Met componenten voor gegevensvisualisatie kunt u gegevens weergeven in de vorm van tabellen, velden en lijsten. De weergegeven gegevens kunnen in tekst-, grafisch of vrij formaat zijn.
Tabellen worden opgeslagen in de database. Sommige DBMS'en slaan de database op in de vorm van verschillende afzonderlijke bestanden die tabellen vertegenwoordigen (in principe allemaal lokale DBMS'en), terwijl andere uit één enkel bestand bestaan dat alle tabellen en indexen bevat (InterBase).
Databaseobjecten in Delphi zijn op SQL gebaseerd en bevatten volledige kracht Borland-database-engine. Delphi bevat ook Borland SQL Link, zodat de toegang tot Oracle-, Sybase-, Informix- en InterBase-databases zeer efficiënt is. Bovendien omvat Delphi lokale server Interbase, zodat u applicaties kunt ontwikkelen die offline kunnen worden uitgebreid naar externe SQL-servers.
Schaalbaarheid in de praktijk - dezelfde applicatie kan worden gebruikt voor zowel lokale als serieuzere client-server-opties.
Hoewel Delphi geen eigen databasetabelformaat heeft, biedt het toch krachtige ondersteuning grote hoeveelheid verschillende DBMS'en - zowel lokaal (bijvoorbeeld dBase of Paradox) als industrieel (bijvoorbeeld Sybase of InterBase).
