Python Paginering Av Postgres

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.

Legg igjen en kommentar

Din e-postadresse vil ikke bli publisert.