Innledning
denne artikkelen er en tutorial På Python Paginering Av Postgres data. Av mange grunner kan det være lurt å begrense retur av recordsets til små biter, i motsetning til å returnere store recordsets som kan være dyrt både når det gjelder båndbredde, RAM og tid på serveren, samt økonomi for brukeren. Vår metodikk:
- Hva og hvorfor? Hva Er Python paginering I PostgreSQL? Hvorfor vil vi paginere Våre Postgres-data med Python og under hvilke omstendigheter?
- hvordan? Hvordan paginerer Vi PostgreSQL-resultater med Python? Hva er de raskeste, enkleste måtene å gjøre dette på for mindre datasett, og hva er de mer robuste og effektive måtene for store databaser og / eller situasjoner der server-eller klientressurser er begrensede og nøyaktighet er avgjørende?
Forutsetninger
- SQL: Forstå grunnleggende om å skrive SQL For Postgres. Vi bruker dBeaver på grunn av sin enkle og antall funksjoner.
- VELG: vi gjør liberal bruk av kommandoen» VELG » i denne artikkelen for å spørre En Postgres-database med Et Python-program.
- Veiledning om navnekonvensjoner som viser hvorfor du kanskje vil prefiks dine variabler, kolonnenavn, tabellnavn, etc. som du ser gjort i denne artikkelen. For eksempel, navngi «tvariable» med » t «prefikset for å definere det som et «tekst» (streng) objekt og» tbl_ » før tabellnavn for å tydelig skille disse objektene som tabeller. Opplæringen går også litt dypere, og snakker om hvordan man navngir variabler basert på et hierarkisystem.
Opprett Et Postgres-bord for å paginere
la oss si at vi lager et forum eller content management system (Cms) I Python og Postgres, og vi vil ha et bord for lagring av foruminnlegg.
1
2 3 4 5 6 7 8 9 10 |
OPPRETT TABELL offentlig.page_contents (
id seriell IKKE NULL, id_session int4 NULL STANDARD 0, id_author int4 NULL STANDARD 0, T_TITLE VARCHAR(256) NULL, t_contents tekst NULL, D_CREATED DATO NULL STANDARD nå(), BEGRENSNING page_contents_pkey PRIMÆRNØKKEL (id) ); opprett unik indeks page_contents_id_idx på offentlig.page_contents BRUKER btree (id); |
Nå som Vi har Et PostgreSQL-bord, fyller vi det med data, så vi har noe å teste med:
1
2 3 4 5 6 7 8 9 10 11 |
SETT inn
page_contents ( id_author , t_title ) VELG TILFELDIG()*100::HELTALL + 1 som id_author , array_to_string(array(VELG substr(‘ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789’,((tilfeldig()*(36-1)+1)::HELTALL), 1) fra generate_series(1,32)),») som t_title; fra generate_Series(1,10000); |
Oversikt: Vi setter inn 10000 poster i vår» page_contents » tabell. For hver post fyller vi feltet» id_author » med et tilfeldig tall mellom 1 og 100, inkludert de to tallene. Vi fyller også feltet» t_title » med en tilfeldig streng på 32 tegn fra alfabetet.
Merk: hvis du trenger et større datasett, øker du bare «10000» du ser ovenfor til et større antall.
Analyse
- INSERT: Brukt PostgreSQL ‘ s «random» funksjon for å generere et tilfeldig tall mellom 0 og 99, kast det som et heltall («::»1», slik at resultatet er mellom (inkludert) 1 og 100 og er av tilstrekkelig datatype til å plassere i kolonnen «id_author».
- array_to_string: vi velger tilfeldig bokstaver 32 ganger («generate_series (1,32)») fra en 36 tegn lang streng Fra A Til Z og 0 til 9 for å bygge en streng som er satt inn i «t_title» – feltet.
- generate_Series(1,10000): Dette forteller Postgres SQL engine å generere 10 000 rader i tabellen.
nå som vi har et stort datasett å jobbe med, la oss se på to forskjellige metoder for å hente data fra denne tabellen ved Hjelp Av Python.
Python paginering Av Postgres rask og skitten metode
den minst effektive, men mest brukte er vanligvis et objekt eller bibliotek som – under-bruker» limit-offset » paginering. For situasjoner der databasen er liten eller middels i størrelse, bør dette fungere fint, med få ulemper, hvis noen. Senere, når vi bruker en mer robust metode, snakker vi om forskjellene.
først, fordelene med noen metode for paginering:
- den første siden av dataene dine lastes raskere. For brukerens oppfatning av hvor fort appen din er, er dette uvurderlig!
- Raskere visninger av store datasett.
- Potensial for forretningslogikkinnkapsling(avhenger av hvordan du gjør det).
- klienten mottar mindre data om gangen, noe som kan være super nyttig, om ikke et krav i visse miljøer.
deretter inkluderer metodene vi bruker total, limit, offset og skip.
la Oss nå se på noen kode:
1
2 3 4 5 6 7 8 9 10 11 12 13 |
page_current = 3
records_per_page = 10 offset = (page_current – 1) * records_per_page s = «» s += » VELG *» s += «fra page_contents» s += «REKKEFØLGE etter id» s += «GRENSE» + records_per_page s += «offset» + offset # resulterende «limit» del av spørringen: «limit 10» # resulterende «offset» del av spørringen: «OFFSET 20» |
Analyse
- page_current: for testformål setter vi opp vår nåværende side til å være 3.
- records_per_page: vi vil bare returnere 10 poster per side.
- offset: dette er parameteren som forteller Postgres hvor langt Å «hoppe» i tabellen. I hovedsak, » Hopp over dette mange poster.»
- s: Oppretter en spørringsstreng for å sende Til PostgreSQL for utførelse.
det største problemet med den ovennevnte «limit offset» – metoden for paginering er at» under dekslene » Postgres legger opp den totale mengden poster, teller sider basert på det nummeret, og skanner indeksen for å telle hvor mange rader. Med de første sidene kan denne kostnaden ikke være tydelig. Men med større recordsets og selv mellomstore seg, jo høyere du øker «page_current», tregere ting vil få. Heldigvis er det mange måter vi kan gjøre paginering Av Postgres data.
en bedre metode: seek and keyset paginering
en løsning som lindrer noen av ulempene forbundet med å bruke metoden ovenfor, er å passere i den unike IDEN til den siste posten på forrige side.
1
2 3 4 5 6 7 8 9 10 11 12 13 14 15 |
ID_page_previous = 200
page_current = 3 records_per_page = 10 # limit_optional_offset ikke lenger nødvendig! limit_optional_offset = (page_current – 1) * records_per_page s = «» s += » VELG *» s += «fra page_contents» s += «hvor id >» & id_page_previous s += «REKKEFØLGE etter id» s += «limit» + records_per_page # s += «offset» + offset # resulterende «limit» del av spørringen: «limit 10» |
Legg Merke til, med denne metoden trenger vi ikke LENGER OFFSET-kommandoen. Ved å legge til» HVOR » – klausulen for å fortelle PostgreSQL å utelate alle tidligere poster, så det vet hvor du skal begynne å vise poster, fortsetter vi Å bruke GRENSE for å kommandere hvor mange poster som skal returneres.
mens det sikkert er mer effektive metoder for å paginere Et Postgres-bord, høster metoden ovenfor enorme fordeler i fart og effektivitet. En svært viktig vurdering er: «id» må indekseres.
Konklusjon
i denne opplæringen lærte vi to metoder for Bruk Av Python for paginering Av Postgres data. Vi begynte med Å lage En PostgreSQL tabell, deretter lagt 10.000 poster til bordet, så vi hadde noe å basere test på, og da vi sammenlignet to metoder for paginering I Python, og til slutt, vi analyserte fordeler og ulemper med begge metodene. I løpet av denne prosessen, gjorde Vi bruk Av PostgreSQL «tilfeldig» funksjon, Python streng sammenkobling for å bygge SQL å sende Til Postgres, og variabel skapelse.