RĪGAS TEHNISKĀ UNIVERSITĀTEDatorzinātnes un informācijas tehnoloģijas fakultāte

Multidatubāzes

Individuālais darbs

Multidatubāzes sistēmas izstrādāšana ar Python/TurboGears izmantošanu

Izstrādāja: Anna Malahova,Apl. Nr. 011LDK010,

DGDB-3Pārbaudīja: prof. Eiduks

2006. / 2007.m.g.

2

Saturs

Ievads....................................................................................................................................................31. Globālās shēmas integrācijas pieeja..................................................................................................4

1.1. Galvenās priekšrocības...............................................................................................................41.2. Galvenie trūkumi un grūtības.....................................................................................................5

2. Multibadubāzes sistēmas projekts.....................................................................................................62.1. MultiDB sistēmas projektēšana..................................................................................................62.2. Projekta izveidošana...................................................................................................................7

3. Datu bāzu izveidošana.......................................................................................................................83.1. SQLite........................................................................................................................................83.2. PostgreSQL..............................................................................................................................113.3. Oracle.......................................................................................................................................14

4. Globālās shēmas izveidošana..........................................................................................................165. Lietojuma izveidošana.....................................................................................................................18

5.1. Pieslēgšanās datu bāzēm un datu iegūšana..............................................................................185.2. Lietotāja saskarnes izveidošana...............................................................................................20

6. Multidatubāzes sistēmas darbība.....................................................................................................22Secinājumi...........................................................................................................................................26Avoti....................................................................................................................................................27

3

Ievads

Šajā darbā tiks izskatīta multidatubāzes sistēmas izveidošana, izmantojot Active Python

programmēšanas valodu un TurboGears izstrādes vidi neviendabīgo datu bāzu sadarbspējas

nodrošināšanai. Multidatubāzu sistēmu darbības mehānisma pamatprincipu izskatīšanai tiks

izmantota globālās shēmas integrācijas pieeja.

Multidatubāzes sistēma ietvers 3 dažādas datu bāzes – SQLite, PostgreSQL un Oracle,

globālo shēmu, kurā būs noteikts, kādas datu bāzes, to tabulas un lauki būs pieejami globālajam

lietotājam, kurš pieslēgsies sistēmai ar Web-orientēta lietojuma palīdzību.

Lai no Python lietojuma būtu iespējams vērsties pie datu bāzes, nepieciešams uzstādīt

attiecīgās datu bāzes saskarni. Pēc adreses http://wiki.python.org/moin/DatabaseInterfaces var atrast

datu bāzu saskarņu sarakstu, kuras ir pieejamas Python izstrādātājiem. Iepriekšminētām datu bāzēm

no šī saraksta var izmantot SQLite 3, psycorpg 2 un cx_Oracle. Pieslēgšanas datu bāzēm caur šīm

saskarnēm tiks izskatīta šajā darbā.

4

1. Globālās shēmas integrācijas pieeja

Globālās shēmas integrācijas pieejas pamatā ir datu dalīšanas nodrošināšana caur globālo

shēmu. Globālā shēma nepieciešama globālo vaicājumu izpildīšanai. Šī pieeja vairāk piemērota

nelielām multidatubāzēm. Integrācijas procesa veikšanai nepieciešams saprast datu semantiku.

Pieejas izmantošana uzliek zināmus ierobežojumus, jo palielinoties shēmu skaitam, tiek pagrūtināta

apstrāde. 1. attēlā globālas shēmas integrācijas pieeja parādīta shematiski.

1. att. Globālās shēmas integrācijas pieeja

1.1. Galvenās priekšrocības

ļauj izpildīt vaicājumus, kas skar daudzas datubāzes;

tiek nodrošināta caurspīdīga pieeja mērķa shēmām.

5

1.2. Galvenie trūkumi un grūtības

nevar pielietot automātisko translāciju shēmas labošanā (update) un integrācijā (izmaiņās

komponentshēmās var izraisīt nepieņemamas izmaiņas globālajā shēmā un otrādi);

nepieciešamība saprast un interpretēt, ko dažādas entītijas nozīmē, un kaut kādā veidā translēt to

no vienas shēmas uz citu;

nepieciešamība uzturēt globālās shēmas komponentshēmu biežas evolucionēšanas dēļ.

Vienas centralizētas shēmas dēļ lēmumu pieņemšana ir centralizēta, līdz ar to pastāv vājas

vietas ātrdarbībā.

6

2. Multibadubāzes sistēmas projekts

2.1. MultiDB sistēmas projektēšana

Kā redzams uz shēmas (2. att.), multidatubāzes sistēma ietver vairākas sastāvdaļas:

neviendabīgus datu avotus; lietojumu, ar kuru strādā globālais lietotājs; globālo shēmu, kur

lietojums atrod informāciju par tām tabulām, kuras ir pieejamas globālajām lietotājam (tabulas īstais

vārds datubāzē un datu bāzes unikālais identifikators (dburi), kas satur informāciju par to, kādā

veidā lietojums var pieslēgties norādītai datu bāzei).

2. att. Multidatubāzes sistēmas struktūra

Jāatzīmē, ka ne visas lokālās datu bāzes tabulas var būt pieejamas globālajam lietotājam,

tāpat kā globālajam lietotājam var būt pieejami tikai atsevišķi tabulas lauki (šim nolūkam var

izmantot skatus). Tādā veidā, no SQLite datu bāzes „darbinieki” globālajam lietotājam būs

pieejamas tikai tabulas „adreses”, „klases”, „apmaksa” un „setnieki”; no PostgreSQL datu bāzes būs

pieejamas visas tabulas un no Oracle datu bāzes būs pieejami 2 skati: „furniture” un „devices” (skat.

sadaļu „Datu bāzu izveidošana”).

7

2.2. Projekta izveidošana

TurboGears vidē jaunā projekta izveidošanai tiek izmantota komanda tg-admin quickstart.

TurboGears projekta inicializēšanas laikā tiek pieprasīts ievadīt projekta nosaukumu un pakotnes

nosaukumu, kā arī noteikt, vai projektā tiks izmantota identifikācija pēc lietotāja vārda un paroles

(3.att.).

3. att. TurboGears projekta inicializēšana

Pēc projekta inicializēšanas pašreizējā direktorijā (uz C: diska) tiks izveidota jauna

direktorija ar nosaukumu ama, kurā būs atrodami arī Web servera konfigurēšanas datnes, veidnes un

citas datnes, nepieciešamas Web lietojuma izstrādes uzsākšanai.

Web servera palaišana un projekta datņu kompilēšana notiek ar komandas „C:\ama>python

start-ama.py” palīdzību (4. attēls). Pēc tās izpildīšanas projektu var atvērt pārlūkprogrammā,

norādot adresi „http://localhost:8080/”.

4. att. Web servera palaišana

8

3. Datu bāzu izveidošana

3.1. SQLite

Lai izveidotu SQLite datu bāzi, komandrindā tiek ievadīta komanda sqlite3, aiz kuras seko

norāde uz vietu, kur glabāsies datu bāzes datne un datu bāzes nosaukums (datu bāzes datnei būs tāds

pats nosaukums, kā datu bāzei): „sqlite3 c:/ama/sqlite_db/darbinieki”. 5. attēlā parādīta datu bāzes

izveidošana un tabulu definēšana.

5. att. SQLite datu bāzes izveidošana. Tabulu definēšana

Ievadīt datus izveidotajās tabulās var līdzīgi tam, kā tās tika definētas – nolāsot datnes ar

SQL skriptu saturu (6. att.). Šim nolūkam SQLite izmanto komandu .read

c:/ama/sql/insert_db1.sql, kur parametrs aiz atslēgvārda .read ir SQL faila nosaukums.

9

10

11

6. att. Datu ievade datu bāzē „darbinieki”

Pēc datu bāzes izveidošanas norādītajā direktorijā jāparādās datnei ar datu bāzes nosaukumu

(7. att.).

7. att. Datu bāzes „darbinieki” datne

SQLite datu bāzē esošās tabulas var tikt apskatītas ar komandas .tables palīdzību. 8. attēlā

parādītas datu bāzes „darbinieki” tabulas un tajās ierakstītie dati.

12

8. att. Datu bāzes „darbinieki” tabulas un tajās ievadītie dati

No visām datu bāzes „darbinieki” tabulām globālajam lietotājam būs pieejamas tikai

„adreses”, „klases”, „apmaksa” un „setnieki”, pie tam, tabulai „sētnieki” tiks piešķirts cits

nosaukums globālajā datu bāzē – tā sauksies „darbinieki”.

3.2. PostgreSQL

Uzsakot darbu ar PostgreSQL, tika izveidots lietotājs anna ar paroli qwuerty123, kura

uzskaites ieraksts tiks izmantots Python lietojumā pieslēgšanai datu bāzei:

> create user anna with login password ‘qwerty123’;

Pēc tam tika izveidota datu bāze, kuras īpašnieks ir jaunizveidots lietotājs:

> create database test with owner =anna;

13

PostgreSQL lietotāji atšķiras no sistēmas lietotājiem. Autentifikācijas datne atrodas

PostgeSQL datu direktorijā – tā ir Host Based Authentication datne ar nosaukumu pg_hba.conf.

PostgeSQL ir vairākas lietotāju autentifikācijas metodes. Pārbaudīsim, lai šīs datnes beigās būtu

norādītas sekojošas rindas:

# TYPE DATABASE USER CIDR-ADDRESS METHOD

local all all trust

host all all 127.0.0.1/32 trust

# IPv4 local connections:

host all all 127.0.0.1/32 md5

Kad datu bāze „test” ir izveidota, var pieslēgties tai kā lietotājs anna ar komandas ar

sekojošās komandas palīdzību:

> psql –U anna test

Tad tiek izveidotas 2 tabulas: „contacts” un „pricelist”. Šo tabulu definēšana parādīta 9.

attēlā.

9. att. Datu bāzes „test” tabulu definēšana

10. attēlā parādīta datu ievade tabulā „contacts”. Ar vienkāršā SELECT vaicājuma palīdzību

tiek pārbaudīts, ka dati tika veiksmīgi ierakstīti tabulā.

14

10. att. Datu ievade tabulā „contacts”

11. attēlā parādīta datu ievade tabulā „pricelist”. Vienkāršais SELECT vaicājums ļauj

pārliecināties, ka dati tika korekti ierakstīti tabulā.

11. att. Datu ievade tabulā „pricelist”

No datu bāzes „test” tabulām globālajām lietotājam būs pieejamas abas tabulas – gan tabula

„contacts”, gan tabula „pricelist”.

15

3.3. Oracle

Kā Orace datu bāzes piemēru izmantosim jau izveidotu telpisko datu bāzi. Lai globālais

lietotājs var piekļūt datiem no 4 šīs datu bāzes tabulām: „mebeles”, „mēbeles_atr”, „iekartas” un

„iekartas_atr”. 12. attēlā parādīta šo tabulu definēšanas informācija.

Izskatīsim, kā var ierobežot tabulas laukus, kuri būs pieejami globālajam lietotājam.

Pieņemsim, ka globālajam lietotājam jābūt iespējai atlasīt un apskatīties lauku „m_num”,

„m_nosaukums” vērtības no tabulas mēbeles un lauku „ma_krasa”, „ma_materiali”,

„ma_izgatavotajs”, „ma_apraksts” vērtības no tabulas „mēbeles_atr”. Savukārt no tabulas iekārtas

viņam būs nepieciešams apskatīties laukus „i_num”, „i_nosaukums”, bet no tabulas „iekartas_atr” –

laukus „ia_izgatavotajs” un „ia_raksturojumi”. Lai to panāktu izveidosim divus skatus, kuri turpmāk

tiks ierakstīti globālajā shēmā un globālais lietotājs vērsīsies nevis tieši pie tabulām, bet pie

izveidotiem skatiem.

12. att. Telpiskās Oracle datu bāzes tabulu definēšanas informācija

13. attēlā parādīta skatu „furniture” un „devices” izveidošana.

16

13. att. Skatu „furniture” un „devices” izveidošana

Kā jau bija minēts, globālajam lietotājam no Oracle datu bāzes būs pieejami tikai divi skati –

„furniture” un „devices”.

17

4. Globālās shēmas izveidošana

Globālai shēmai izveidosim vienu tabulu ar nosaukumu „global_schema”. Ievietosim to jau

izveidotajā PostgreSQL datu bāzē „tests”. 14. attēlā parādīta globālās shēmas izveidošana

informācijas par globāli pieejamām tabulām ievadīšana.

Redzams, kā tabula „global_schema” satur 4 laukus:

1. „alias” – lauks, kurā glabājas tabulas nosaukums globālajā datu bāzē (multidatubāzu

sistēmā);

2. „tablename” – lauks, kurā atrodams tabulas īstais nosaukums lokālajā datu bāzē;

3. „dburi” – lauks, kas satur datu bāzes unikālo identifikatoru, kurš, savukārt, satur

informāciju par datu bāzes tipu, atrašanas vietu un nosaukumu;

4. „id” – primārās atslēgas lauks, kas satur tabulas ieraksta identifikatoru.

18

14. att. Globālās shēmas izveidošana

19

5. Lietojuma izveidošana

5.1. Pieslēgšanās datu bāzēm un datu iegūšana

Pieslēgšanās neviendabīgām datu bāzēm un datu iegūšana tiks realizēta Python valodā.

Zemāk ir atrodams datnes ama/controllers.py saturs, kur komentāros aprakstītas izveidotas

funkcijas un visas veicamās darbības. CherryPy, kas ir TurboGears sastāvdaļa, sniedz iespēju viegli

strādāt ar pavedieniem un datu bāzu pieslēgumiem, nepievēršot uzmanību tādiem zema līmeņa

detāliem, kā protokolu, savienojumu (socket) un procesu/pavedienu vadība. Datu bāzes saskarnes

moduļa uzstādīšana dod iespēju Python interpretatoram piekļūt datu bāzei un izpildīt vaicājumus.

Tā kā TurboGears Web serveris tika uzstādīts uz datora, kur jau bija Oracle 9i ar Apache

Web serveru, lai nerastos konflikta šo serveru starpā pora 8080 dēļ, TurboGears projektam šis ports

tika izmainīts uz 8081 – rinda „server.socket_port=8081” datnē dev.cfg.

Datne ama/controllers.py

# Skripta sākumā importējam moduļus, kas neietilpst Python valodāfrom turbogears import controllers, exposefrom model import *from cherrypy import request, responseimport cherrypyfrom pysqlite2 import dbapi2 as sqliteimport psycopg2import cx_Oracle

def connect(thread_index): # Izveidojam pieslēgumus datu bāzēm un ievietojam tos pašreizējā pavedienā

(thread)try:

cherrypy.thread_data.db1 = sqlite.connect("c:/ama/sqlite_db/darbinieki")cherrypy.thread_data.db2 = cx_Oracle.connect('system/malahova@studydb')cherrypy.thread_data.db3 = psycopg2.connect("dbname='test' user='anna'

host='localhost' password='qwerty123'")except:

print "I am unable to connect to the database"

cherrypy.server.on_start_thread_list.append(connect)

class Root(controllers.RootController):# Ja pārlūkprogrammas loga adreses laukā ievadīt „http://localhost:8081/”,# tiks parādīta TurboGears sākumlapa, kurai atbilst veidne

ama/templates/welcome.kid@expose(template="ama.templates.welcome")

20

def index(self): import time# log.debug("Happy TurboGears Controller Responding For Duty")return dict(now = time.ctime())

# Lappuse, kura tiks attēlota, ja pārlūkprogrammas loga adreses laukā ievadīt# „http://localhost:8081/dblist” , kurai atbilst veidne

ama/templates/showdblist.kid@expose(template = "ama.templates.showdblist", allow_json = True)def dblist(self):

# PostgreSQL datu bāzei „test” izmantosim kursoruc = cherrypy.thread_data.db3.cursor()# Izpildām vaicājumu globālai shēmai,# kura rezultātā tiek iegūts tabulas vārds globālajā datu bāzē un tabulas

idquery = """

SELECT alias, idFROM global_schema;

"""c.execute(query)# Ievietojām atlasītos ierakstus masīvārows = []while (1):

row = c.fetchone()if row == None:

breakrows.append(row)

c.close()# Funkcija dblist(self) nodod veidnei kā parametru vārdnīcu,# kurā ir viena atslēga – vaicājuma izpildīšanas rezultātā atlasīto ierakstu

masīvsreturn dict(tables = rows)

# Lappuse, kura tiks attēlota, kad pārlūkprogramma vērsīsies pie adreses# „http://localhost:8081/showtable” , kurai atbilst veidne

ama/templates/showtable.kid# Pie izsaukšanas saņem kā parametru tabulas id vērtību @expose(template = "ama.templates.showtable", allow_json = True)def showtable(self, id):

# PostgreSQL datu bāzei „test” izmantosim kursoruc = cherrypy.thread_data.db3.cursor()# Izpildām vaicājumu globālai shēmai, kura rezultātā tiek iegūts norādītās# tabulas dburi, īsts vārds lokālajā DB un tabulas vārds globālajā DBquery = """

SELECT dburi, tablename, aliasFROM global_schemaWHERE id = %d

""" % int(id)c.execute(query)# No kursora tiek saņemtas atlasīta ieraksta lauku vērtības# ar tabulas dburi, vārdu un globālo nosaukumuconnparams = c.fetchone()dburi = connparams[0]table = connparams[1]alias = connparams[2]# Atkārībā no mainīgā dburi vērtības, tiek izvēlēts,

21

# kuras datu bāzes kursoru nepieciešams izveidotc = {"sqlite://localhost/darbinieki" : cherrypy.thread_data.db1.cursor(), "sqlite://127.0.0.1/darbinieki" : cherrypy.thread_data.db1.cursor(), "oracle://localhost/studydb" : cherrypy.thread_data.db2.cursor(), "psycopg2://localhost/test" : cherrypy.thread_data.db3.cursor(),}[dburi]# Vaicājums, kura izpildīšanas rezultātā tiek iegūti visi ieraksti no uzdotās

tabulasquery = """

SELECT *FROM %s

""" % tablequery = query.lstrip().rstrip()c.execute(query)# Ievietojām atlasītos ierakstus masīvārows = []while (1):

row = c.fetchone()if row == None:

breakrows.append(row)

# Ievietojām masīvā norādītās tabulas lauku nosaukumuscolumns = []for fieldDesc in c.description:

column = fieldDesc[0]if column == None:

breakcolumns.append(column)

c.close()# Funkcija showtable(self, id) nodod veidnei kā parametru vārdnīcu,# kurā ir 3 atslēgas: norādītās tabulas ierakstu masīvs, tabulas vārds globālajā

DB# un tabulas lauku nosaukumu masīvsreturn dict(rows = rows, tablename = alias, fieldnames = columns)

5.2. Lietotāja saskarnes izveidošana

Multidatubāzes sistēmas saskarne ar lietotāju tiks īstenota ar divām Web lappusēm: uz

pirmās lappuses globālajam lietotājam tiks piedāvāts izvēlēties tabulu no visu datu bāzu globāli

pieejamo tabulu saraksta, uzklikšķinot uz kuras nosaukuma notiks pāreja uz otru lappusi, kurā tiks

izvadīti visi izvelētās tabulas ieraksti. Pirmās lappuses saturs aprakstīts ar xml palīdzību veidnē

ama/templates/showtable.kid, bet otrās lappuses saturs – veidnē ama/templates/showdblist.kid.

Šo datņu saturs atrodams zemāk.

Datne ama/templates/showdblist.kid<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml" xmlns:py="http://purl.org/kid/ns#" py:extends="'master.kid'"><head>

<meta content="text/html; charset=utf-8" http-equiv="Content-Type" py:replace="''"/>

22

<title></title></head>

<body><h1>Multidatubāzu sistēma</h1><ul>

- - Izmantojam for ciklu, lai izvadītu masīvā tables atrodamus- - tabulu globālos nosaukumus nesakārtotā saraksta veidā.<li py:for="table in tables">

<a href="showtable?id=${table[1]}" py:content="table[0]"></a></li>

</ul></body>

</html>

Datne ama/templates/showtable.kid<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml" xmlns:py="http://purl.org/kid/ns#" py:extends="'master.kid'"><head>

<meta content="text/html; charset=utf-8" http-equiv="Content-Type" py:replace="''"/><title></title>

</head><body>

[<a href="/dblist">BACK</a>]<p/><h2>Displaying table: ${tablename}</h2><table class="mytable"><tr class="header">

- - Ar for cikla palīdzību izvadam tabulas kolonu nosaukumus- - no masīva fieldnames<th class="mycell" py:for="field in fieldnames" py:content="field"/>

</tr>- - Tabulas pāra rindas izceļam ar pelēko krāsu<tr py:for="i,row in enumerate(rows)" class="${i%2 and 'odd' or 'even'}">

- - Ar cikla palīdzību aizpildām tabulas šūnas ar datiem no masīva<td class="mycell" py:for="cell in row" py:content="cell"/>

</tr></table>

</body></html>

Izveidoto tīmekļa lappušu izskatu var mainīt ar CSS palīdzību. Izskatītajā gadījumā datnē

ama/static/css/style.css tika pievienotas 4 jaunas klases, kuras apraksta tabulas, tabulas nosaukuma,

šūnu un pāra rindu izskatu.

Datne ama/static/css/style.css.mytable { font-size: 100%; border: 1px solid; border-collapse: collapse; }.header {

23

background: #aaaaaa; }.mycell { border: 1px solid; padding: 10px; margin: 0; text-align: center; }.odd { background: #eeeeee; }

24

6. Multidatubāzes sistēmas darbība

Lai pārbaudītu multidatubāzes sistēmas darbību, palaidīsim Web serveru izveidotajam

projektam (ievadot komandrindā „python C:\ama\start-ama.py”) un pārlūkprogrammas loga

adreses laukā ievadīsim „http://localhost:8081/dblist”. 15. attēlā paradīta tīmekļa lappuse, kura tiek

attēlota ievadot norādīto adresi. Šī lappuse satur globāli pieejamo tabulu sarakstu – nosaukumi,

piešķirtie tabulām globālajā shēmā, kuri tiek attēloti kā saites. Uzklikšķinot uz jebkuras no šīm

saitēm, lietotājam tiek parādīts izvēlētās tabulas dati.

15. att. Multidatubāzes tabulas, pieejamas globālajam lietotājam

16. attēlā parādīta datu izvade no SQLite datu bāzes „darbinieki” tabulas „setnieki”, kurai

globālajā shēmā piešķirts nosaukums „Darbinieki”.

25

16. att. Datu izvades piemērs no SQLite datu bāzes tabulas

17. attēlā parādīta datu izvade no Oracle datu bāzes „studydb” skata „furniture”, kuram

globālajā shēmā piešķirts nosaukums „Mēbeles”.

26

17. att. Datu izvades piemers no Oracle datu bāzes tabulas

18. attēlā parādīta datu izvade no PostgreSQL datu bāzes „test” tabulas „contacts”, kurai

globālajā shēmā piešķirts nosaukums „Kontakti”.

27

18. att. Datu izvades piemērs no PostgreSQL datu bāzes tabulas

28

Secinājumi

Darbā tika izskatīta multidatubāzes sistēmas izveidošana, izmantojot Active Python

programmēšanas valodu un TurboGears izstrādes vidi neviendabīgo datu bāzu sadarbspējas

nodrošināšanai. Multidatubāzu sistēmu darbības mehānisma pamatprincipu izskatīšanai tika

izmantota globālās shēmas integrācijas pieeja.

Globālās shēmas integrācijas pieejas pamatā ir datu dalīšanas nodrošināšana caur globālo

shēmu. Šai pieejai ir savas priekšrocības un trūkumi, bet jāatzīmē, ka tā ir vairāk piemērota nelielām

multidatubāzēm. Pieejas izmantošana uzliek zināmus ierobežojumus, jo palielinoties shēmu skaitam,

tiek pagrūtināta apstrāde.

Uzprojektēta multidatubāzes sistēma ietver 3 sastāvdaļas: 1) neviendabīgus datu avotus, 2)

lietojumu, ar kuru strādā globālais lietotājs, un 3) globālo shēmu, kur lietojums atrod informāciju par

tām tabulām, kuras ir pieejamas globālajām lietotājam (tabulas īstais vārds datubāzē un datu bāzes

unikālais identifikators (dburi), kas satur informāciju par to, kādā veidā lietojums var pieslēgties

norādītai datu bāzei).

Izveidotā multidatubāzes sistēma ietver 3 dažādas datu bāzes – SQLite, PostgreSQL un

Oracle, globālo shēmu, kurā noteikts, kādas datu bāzes, to tabulas un lauki ir pieejami globālajam

lietotājam, kurš pieslēdzās sistēmai ar Web-orientēta lietojuma palīdzību.

Pieslēgšanās neviendabīgām datu bāzēm un datu iegūšana tika realizēta Python valodā.

CherryPy, kas ir TurboGears sastāvdaļa, sniedz iespēju viegli strādāt ar pavedieniem un datu bāzu

pieslēgumiem, nepievēršot uzmanību tādiem zema līmeņa detāliem, kā protokolu, savienojumu

(socket) un procesu/pavedienu vadība. Datu bāzes saskarnes moduļa uzstādīšana dod iespēju Python

interpretatoram piekļūt datu bāzei un izpildīt vaicājumus.

29

Avoti

1. Bouguettaya, M. Papazoglou and R. Kings. On Building Hyperdistributed Database. In

Information Systems, Great Britain, volume 20, No. 7, pp. 557-577 (1995).

2. Guido van Rossum. Python Tutorial. – http://docs.python.org/tut/tut.html

3. Python Database Interfaces. http://wiki.python.org/moin/DatabaseInterfaces

4. TurboGears: Front-to-Back Web Development. – http://www.turbogears.org/

5. TurboGears Documentation. The 20 Minutes Wiki. –

http://docs.turbogears.org/1.0/Wiki20/Page1

6. SQLite home page. http://www.sqlite.org/

7. SQLite Tutorial by Mike Chirico. –

http://souptonuts.sourceforge.net/readme_sqlite_tutorial.html

8. pysqlite usage guide. – http://initd.org/pub/software/pysqlite/doc/usage-guide.html

9. PostgreSQL 8.3devel Documentation. – http://developer.postgresql.org/pgdocs/postgres/

10. PostgreSQL 8.3devel Documentation. The pg_hba.conf file. –

http://developer.postgresql.org/pgdocs/postgres/auth-pg-hba-conf.html

11. Accessing PostgreSQL with Python and Psycopg2. –

http://www.devx.com/opensource/Article/29071/0

12. Wrapping Your Brain Around Oracle + Python. –

http://www.oracle.com/technology/pub/articles/devlin-python-oracle.html

30