PostgreSQL - funktioner

Som i de flesta databaser kan vi kedja en rad meningar SQL och behandla dem som en enhet i ett funktionsblock; de olika databaserna beskriver denna operation med olika namn, lagrade procedurer, moduler, makron, etc.

I PostgreSQL de kallas funktioner. Bortsett från att förena flera SQL -satser ger dessa funktioner oss också möjligheten att köra SQL -satser med hjälp av procedurspråk (PL).

I PostgreSQL vi har flera alternativ för detta och möjligheten att utöka dem.

1. PostgreSQL -funktioner

Funktionens anatomi
Oavsett vilket språk som används för att skriva funktionerna har de en struktur, denna struktur kan syntetiseras med följande:

 SKAPA ELLER ERSÄTT FUNKTION func_name (arg1_arg1datatype) RETURNS some_type / setoff sometype / TABLE / (…) / AS $$ BODY off function $$ LANGUAGE language_of_function

Om vi ​​beskriver det vi ser är det ganska enkelt, SKAPA ELLER ERSÄTT FUNKTIONEN är funktionsskapandeklausulen, func_name är namnet som arg1 kommer att ha är parametern som den kommer att ta emot och arg1_datatype är den typ av data som sägs parameter, det vill säga om det är ett heltal, en sträng, etc. I RETURER Vi returnerar resultatet av vår funktion, $$ är början på blocket som kommer att ge vika för funktionens kropp och slutar sedan detsamma med $$ och slutligen SPRÅK tillåter oss att ange språket där funktionen är skriven.

Det är en väldefinierad och ganska läsbar struktur så vi ska inte ha problem med att skapa våra funktioner.

Skrivfunktioner med SQL
Skriv funktionerna med SQL Det är ganska enkelt och snabbt, det är att ta våra SQL -uttalanden i princip och lägga till sidhuvudet och sidfoten för funktionerna till det och vi är klara.

Men som allt annat kommer detta att kosta vissa uppoffringar, till exempel tappar vi flexibiliteten att om vi kunde arbeta med ett annat språk för att skapa fler grenar av villkorlig körning, kan vi inte ha mer än ett SQL -uttalande, även om detta kan åtgärdas med olika metoder.

Den största fördelen är att eftersom SQL är schemaläggaren PostgreSQL tillåter oss att dra nytta av indexen och därmed påskynda dess utförande, å andra sidan med andra språk kommer funktionen alltid att vara en svart ruta

Låt oss nu titta på en funktion skriven med SQL:

 SKAPA ELLER ERSÄTT FUNKTION ins_logs (param_user_name varchar, param_description text) RETURNS integer AS $$ INSERT INTO logs (user_name, description) VALUES ($ 1, $ 2) RETURNING log_id; $$ SPRÅK 'sql' VOLATILE;

Vi ser att vi följer strukturen som definierats ovan och i slutet i avsnittet SPRÅK vi definierar "sql" -klausul FLYKTIG Att den äger betyder att funktionen kan returnera något annorlunda för varje samtal som görs till den, även om den får samma parametrar. För att sedan kalla vår funktion kan vi använda:

 VÄLJ ins_logs ('lhsu', 'detta är ett test') Som nytt_id;

Vi gör en mening VÄLJ, funktionen är aktiv och vad som returnerar är vad vi kommer att få och i det här fallet kommer vi att se ett värde som vi kallar new_id och som funktionen returnerar som log_id.
Vi kan till och med använda en funktion för att göra en postuppdatering och returnera en ogiltig parameter som i detta exempel:

 SKAPA ELLER ERSÄTT FUNKTION upd_logs (log_id integer, param_user_name varchar, param_description text) RETURNS void AS $$ UPDATE logs SET user_name = $ 2, description = $ 3, log_ts = CURRENT_TIMESTAMPWHERE log_id = $ 1; $$ LANGUAGE 'sq' ' FLYKTIG '

Eftersom vi är ogiltiga behöver vi inte ett mottagarfält så vi kör det enligt följande:

 VÄLJ upd_logs (12, 'robe', 'Change to regina');

Här kan vi se att vi tog bort det sista steget i Som nytt_id från föregående samtal.
Med detta avslutar vi denna handledning, vi kan nu göra våra grundläggande funktioner i SQL, vilket underlättar och förenklar många aktiviteter som vi kan behöva inom ett program eller system som vi bygger.

2. PostgreSQL -funktioner på andra språk

En av de mest attraktiva egenskaperna hos PostgreSQL är att det inte bara är begränsat till SQL -språkTack vare laddningen av moduler kan vi välja att införliva avancerade funktioner, inklusive möjligheten att använda olika språk för att bygga funktioner, med detta kan vi uppnå stor flexibilitet med bättre generationskapacitet för villkor och de fördelar som finns i de olika språken.

Skrivfunktioner med PL / pgSQL
För närvarande när vi märker att SQL -standarden inte uppfyller de frågor som vi vill utföra i en funktion kan vi alltid använda PL / pgSQL; en av dess skillnader och förbättringar i förhållande till SQL är att lokala variabler kan deklareras med hjälp av DECLARE -satsen, vi kan också ha kontroll över flödet och vi måste omsluta funktionens kropp i ett BEGIN END -block.

Låt oss se ett exempel på en funktion skriven på detta språk:

 SKAPA FUNKTION sel_logs_rt (param_user_name varchar) RETURNS TABLE (log_id int, user_name varchar (50), beskrivningstext, log_ts timestamptz) AS $$ BEGIN RETURN QUERY SELECT log_id, user_name, description, log_ts FROM logs WHERE user_name = param_ SLUTET; $$ SPRÅK 'plpgsql' STABIL; 

Låt oss nu se hur man skriver funktioner med Python.

Skrivfunktioner med Python
Python är ett ganska rent programmeringsspråk, som har ett stort antal bibliotek tillgängliga.
PostgreSQL är den enda databasmotorn som låter dig använda Python för att bygga funktioner.

För att få möjlighet att skapa funktioner med Python måste vi först se till att språket är installerat på vår server. När vi vet att vi har det installerat måste vi aktivera tilläggen inom PostgreSQL med följande kommandon:

 SKAPA UTÖKNING plpython2u; SKAPA UTÖKNING plpython3u; 

Vi måste se till att Python är igång innan vi aktiverar tilläggen för att undvika fel.

Grundläggande funktioner med Python
När vi har aktiverat allt för att kunna använda Python ska vi börja bygga vår funktion, det är viktigt att veta att PostgreSQL kan konvertera sina datatyper till Python -datatyper och vice versa. PL / Python kan till och med returnera matriser och sammansatta typer.

Låt oss se nedan en funktion som utför en textsökning i en online -resurs, något som inte kunde göras med PL / pgSQL, i följande bild ser vi koden och sedan gör vi motsvarande förklaring.

• Vi importerar de bibliotek som vi ska använda.
• Vi gör webbsökningen genom att sammanfoga användarens inmatningsparametrar.
• Vi läser svaret och sparar det i en HTML -fil som heter raw_html.
• Vi sparar den del av HTML som börjar med och slutar innan.
• Vi tar bort HTML -taggar och blanksteg och sparar variabeln som kallas resultat igen.
• Vi returnerar det slutliga resultatet.
• En annan intressant egenskap med att använda Python är att vi kan interagera direkt med operativsystemet, låt oss se en funktion som gör en katalogförteckning, det bör noteras att detta måste skapas av en superanvändare:

 SKAPA ELLER ERSÄTT FUNKTION list_incoming_files () RETURNS SETOF text AS $$ import os return os.listdir ('/ incoming') $$ LANGUAGE 'plpython2u' VOLATILE SECURITY DEFINER;

Vad är användningen av detta? Vi kan fråga oss själva, för tänk oss att vi vill konsultera de filer som vi har tillgängliga i ett system, samtalet till funktionen skulle vara ungefär så här:

 VÄLJ filnamn FRÅN list_incoming_files () Som filnamn VAR filnamn ILIKE '% .csv'

Med detta avslutar vi denna handledning, vi hanterar redan skapandet av funktioner på andra språk på PostgreSQL, vilket ger oss ett oändligt fält när det gäller att uppfylla våra krav.