Meny

PL SQL-samlingar: Nested Table, Associative Array And Varray

  • Huvud
  • Övrig
  • PL SQL-samlingar: Nested Table, Associative Array And Varray

pl sql collections nested table

Prova Vårt Instrument För Att Eliminera Problem

Lär dig grunderna i PL SQL-samlingar, insamlingsmetoder, Varray, nestad tabell och associativ matris med hjälp av kodexempel:

I PL / SQL-underprogram handledning av PL / SQL-serien , vi lärde oss om procedurer och funktioner, olika parameteröverföringsmetoder och hur man skapar / tar bort procedurer och funktioner i PL / SQL.

I den här artikeln kommer vi att diskutera PL SQL-samlingar och relaterade begrepp. Vi kommer också att förklara begreppet Varrays, kapslade tabeller och index-by-tabeller som finns i PL / SQL.

Dessutom kommer vi att utforska några av de inbyggda samlingsundantagen och samlingsmetoderna.

PL SQL-samlingar och matriser

Vad du kommer att lära dig:

PL SQL-samlingar

En samling är en grupp av element av homogena datatyper. Den innehåller vanligtvis matriser, listor, uppsättningar och så vidare. Var och en av elementen har ett särskilt abonnemang som återspeglar dess position.

PL SQL-samlingar är av följande typer:

  1. Associative Array / Index-by-tabeller
  2. Kapslade bord.
  3. Varrays.

PL SQL-samlingar används vanligtvis för lagring och manipulation av stora bitar av data med hjälp av nyckelordet BULK COLLECT i Oracle.

Insamlingsmetoder

Pl / SQL har några inbyggda metoder under insamling som listas nedan.

Sl. Nej.namnBeskrivningar
7 nästa (m) Ger indexet som följer mth index.
ett räkna Ger antalet element som finns i samlingen.
två begränsa Verifierar samlingsstorleken.
3 existerar (m) Returnerar true om mth-elementet som finns i samlingen annars returnerar false.
4 först Ger startindexnummer i samling med heltal prenumeration.
5 sista Ger slutindexnummer i samling med heltal prenumeration.
6 förlänga Lägger till NULL-element i samlingens slut.
8 föregående (m) Ger indexet som föregår m-indexet.
9 trim Tar bort ett element från slutet av samlingen.
10 trimma (m) Raderar m-element från slutet av samlingen.
elva radera Raderar alla element från samlingen och ställer in antalet till 0.
12 ta bort (m) Raderar mth-elementet från samlingen, om mth-elementet är NULL, utförs ingen åtgärd.
13 ta bort (m, k) Raderar element från mth till kth-position.
14 förläng (m) Lägger till m-element i samlingsänden.
femton förlänga (m, k) Lägger till m-kopior av kth-elementet i slutet av samlingen.

Samlingsundantag

Några av de vanliga samlingsundantagen är följande:

  1. VALUE_ERROR: Detta undantag kastas om ett prenumeration inte kan konverteras till nyckeltypen eller är NULL. Detta undantag höjs normalt om en nyckel är av typen PLS_INTEGER-intervall och prenumerationen ligger utanför detta intervall.
  2. INGEN INFORMATION HITTAD: Detta undantag kastas av PL / SQL om antingen en SELECT-sats inte hämtar några rader eller om ett program pekar på ett element som raderas i en kapslad tabell. Detta undantag kan också tas upp med ett element som inte är initialiserat i en index-by-tabell.
  3. COLLECTION_IS_NULL: Detta undantag kastas av PL / SQL om samlingen är NULL som standard.
  4. SUBSCRIPT_BEYOND_COUNT: Detta undantag kastas när ett abonnemang är mer än det totala antalet av element i samlingen.
  5. PRENUMERATION_OUTSIDE_LIMIT: Detta undantag kastas när ett prenumeration ligger utanför tröskelvärdet.

Kapslade tabeller i PL / SQL

De kapslade tabellerna är som en enda kolumndatabas eller en 1-dimensionell matris där matrisstorleken är dynamisk. Dess prenumeration är av numerisk typ. Vi kan få den kapslade tabellen till en variabel genom att ge raderna ett prenumeration som börjar med 1. Denna funktion gör att den liknar en matris.

En kapslad tabell kan hållas i en kolumn i en databas. Det kan också användas för att manipulera SQL-operationer genom att gå med i tabeller. Eftersom det är som en dynamisk matris så kan den övre gränsen vara av vilken storlek som helst.

En kapslad tabell kan ha både täta och glesa samlingsegenskaper, vilket innebär att alla element kan raderas slumpmässigt (gör det gles) med hjälp av DELETE-proceduren. Radering av data orsakar diskontinuitet i indexet men NEXT-funktionen hjälper till att iterera till nästa prenumeration. Eftersom data lagras i form av en tabell kan de hämtas med hjälp av SELECT-satser.

En kapslad tabell kan byggas på schemanivå eller i PL / SQL-block. Det är som ett databasobjekt som är tillgängligt i databasen eller underprogrammet.

Skillnader mellan tabellen Array och Nested listas nedan:

  • Storleken på de kapslade tabellerna kan ökas dynamiskt. Den övre gränsen för en matris är fast men den är inte fast för kapslade tabeller.
  • Matrisen har på varandra följande prenumerationer vilket gör den tät. En kapslad tabell är dock tät vid skapandet men blir gles när elementen raderas däremellan.

Syntax för den kapslade tabellen:

TYPE <> IS TABLE OF <> (NOT NULL);

Här, 'typ' är typspecifikatorn. 'element' är datatypen.

Kodimplementering med den kapslade tabellen:

DECLARE TYPE subject IS TABLE OF VARCHAR(15); TYPE teacher IS TABLE OF VARCHAR2(20); subjectnames subject; subjectteacher teacher; summ integer; BEGIN -- adding subject and its teachers to the table subjectnames := subject('PLSQL', 'SELENIUM', 'JMETER'); subjectteacher:= teacher('Sashi', 'Mala', 'Mukund'); -- returns count of number of elements in nested table summ:= subjectteacher.count; -- printing the content to the console dbms_output.put_line('Total Number of Teachers: '|| summ); FOR i IN 1 .. summ LOOP dbms_output.put_line('Subject:'||subjectnames(i)||', Teacher:' || subjectteacher(i)); end loop; END;

Utgången för ovanstående kod ska vara:

Kapslad tabellutmatning

Associativ matris eller index-by-tabeller

Index-by-tabellen kallas vanligtvis den associerande matrisen. När det gäller struktur är både index-för-tabellen och kapslade tabeller lika och har abonnemang för att komma åt elementen.

En associativ matris representeras av ett nyckel-värdepar. Var och en av de unika nycklarna används för att identifiera värdet i matrisen. Datatypen för nyckeln kan definieras som en sträng eller ett heltal när den skapas. En nyckel läggs till i index-by-tabellen genom att helt enkelt tilldela ett värde för första gången. För att ändra samma post måste vi använda samma tangent.

Nyckeln ska vara unik antingen som en primär nyckel i en tabell eller genom att kombinera strängar tillsammans för att utveckla unikt värde. Denna typ av samling har en arraystorlek som är dynamisk och har antingen glesa eller täta egenskaper. En skillnad mellan index-för-tabellen och den kapslade tabellen är att den förra inte kan lagras i kolumnen i databasen men den kapslade tabellen kan lagras.

Associerande matriser ger enkelt underhåll av abonnemang och skapas i ett PL / SQL-block. Det är som en SQL-tabell där värden erhålls med hjälp av primärnyckeln. Detta används vanligtvis för tillfällig datalagring och kan användas istället för SQL-tabeller för att undvika nätverkstrafik och disklagring som krävs av SQL-tabeller.

Eftersom de associerande matriserna inte lagrar beständiga data kan de inte användas med SQL-satser som SELECT och INSERT. De kan dock göras oändliga för en session i databasen genom att deklarera deras datatyp som ett paket och definiera dem i paketets kropp.

Syntax för index-by-tabellen:

TYPE type IS TABLE OF element (NOT NULL) INDEX BY (BINARY_INTEGER | PLS_INTEGER | VARCHAR2(size)); INDEX BY key;

Här, den 'nyckel' är numeriskt. Det kan vara antingen BINARY_INTEGER eller PLS_INTEGER. Dess datatyp kan vara varchar, varchar2, long eller string. Den varcharbaserade nyckeln bör nämnas med längd.

'element' är datatypen.
'storlek' är det maximala antalet element. Det är ett positivt heltal.
'typ' är typspecifikatorn.

Kodimplementering med index-by-tabellen:

DECLARE TYPE age IS TABLE OF NUMBER INDEX BY VARCHAR(25); age_empl age; employee VARCHAR(25); BEGIN -- adding employee details to the table age_empl('Sam') := 30; age_empl('Venu') := 35; -- printing the table contents in the console employee := age_empl.FIRST; WHILE employee IS NOT null LOOP dbms_output.put_line ('Employee name is ' || employee || ' and age is ' || TO_CHAR(age_empl(employee))); employee := age_empl.NEXT(employee); END LOOP; END; /

Utgången för ovanstående kod ska vara:

index-by-tabellutdata

Varianter i PL / SQL

Varrays lagrar ett fast antal element och är som en endimensionell matris. Antalet element kan dock ändras vid körning. Det är en följd av element av liknande datatyper. Den kan lagras i en databastabell som kan hanteras med hjälp av SQL-uttalanden. Men processen är inte lika enkel och flexibel som i en kapslad tabell.

Den maximala storleken på Varray definieras i dess typdefinition. Den har ett efter varandra minnesarrangemang som börjar med ett abonnemang och den lägsta platsadressen pekar på startelementet och den högsta platsadressen pekar på slutelementet. Alla element i en Varray identifieras med ett index.

Denna typ av samling har numeriskt abonnemang och har täta egenskaper. Därför kan arrayelementen inte tas bort däremellan. Antingen bör hela Varray raderas eller så kan dess slut klippas. På grund av dess täta egenskaper har den mindre flexibilitet att använda.

Varray kan skapas antingen inom ett PL / SQL-block eller på schemat. Det behandlas som ett databasobjekt som kan nås i databasen eller i ett underprogram. Varray används oftare när storleken på arrayen är känd för oss. Det bör initieras innan du använder dem och det kan initieras med hjälp av en konstruktör. Dess värde är NULL när det deklareras och bör initialiseras innan det refereras till dess element.

Syntax of Varray:

TYPE <> IS VARYING ARRAY (<>) OF <> (NOT NULL);

Här,
'typ' är typspecifikatorn.
'element' är datatypen.
'storlek' är det maximala antalet element i en matris. Det är ett positivt heltal.

Deklaration och initialisering av variabler

Efter att ha skapat ett Varray kan vi förklara det på det sätt som beskrivs nedan:

Syntax:

name type_n (:= type_n(...));

Här,
'namn' är Varray-namnet.
'Typ_n' är typen av Varray.
'Typ_n (...)' är konstruktören av typen Varray. Argumentlistorna nämns av en kommaseparator och av typen Varray.

Vi måste initialisera en Varray-variabel innan vi använder den annars ger det oinitialiserat samlingsfel. Initieringen görs på det sätt som beskrivs nedan.

Syntax:

name type_n := type_n();

Detta initierar variabeln med noll element. För att fylla i element i variabelvariablerna, syntaksen är:

name type_n := type_n(e1, e2, ...);

Åtkomst till element i Varray

Elementen kan nås genom den process som beskrivs nedan:

namn (m); där m är elementindexet som börjar med 1 och slutar med det maximala antalet av element av typen Varray. Om m ligger utanför intervallet 1 och det maximala antalet av element, SUBSCRIPT_BEYOND_COUNT undantag kastas av PL / SQL.

Storleken på Varray kan ändras med hjälp av ALTER-uttalandet.

Kodimplementering med ALTER.

CREATE Or REPLACE TYPE names AS VARRAY(2) OF VARCHAR(5); /

Utgången från ovanstående kod ska vara.

exempel på internet av saker enheter

Utmatning av kod med ALTER

Kodimplementering med Varray:

DECLARE type countrynames IS VARRAY(3) OF VARCHAR2(50); type currency IS VARRAY(3) OF VARCHAR2(15); country countrynames; cur currency; addition integer; BEGIN -- adding country and its currency to the table country := countrynames('INDIA', 'USA', 'UK'); cur:= currency('INR', 'DOLLAR', 'POUND'); -- returns count of number of countries in varray addition := country.count; -- printing the content to the console dbms_output.put_line('Total Number of countries : '|| addition); FOR i in 1 .. addition LOOP dbms_output.put_line('Country: ' || country(i) || ' ,Currency : ' || cur(i)); END LOOP; END; /

Utgången för ovanstående kod ska vara:

Varray-kodutmatning

Skillnader mellan Varrays och kapslade tabeller

Skillnaderna är följande:

  • Medan vi arbetar med ett scenario där antalet element är känt och de ordnas i följd används vanligtvis Varrays. Ett Varray som lagras i en databas behåller sina prenumerationer och sekvens. Det upprätthålls alltid som ett enda objekt. De kapslade tabellerna används när antalet element inte är begränsat.
  • Den kapslade tabellen har glesa egenskaper som gör att den kan ta bort alla element från valfri position och inte alltid från slutet. Ordningen och prenumerationen på en kapslad tabell bibehålls inte när den lagras i databasen. Elementen i Varray bibehålls alltid i följd.

Skillnader mellan associerade arrangemang och kapslade tabeller

Skillnaderna är följande:

  • Kapslade tabeller kan lagras i en kolumn i databasen men associerande matriser är det inte. De kapslade tabellerna upprätthåller korrekta dataförhållanden som lagras ihållande.
  • De associerande matriserna är bra för små uppslagstabeller där samlingen kan byggas i minnet varje gång ett paket initialiseras eller en procedur anropas. De är ett bra val när storleken inte är känd i förväg. Indexvärdena för en associerad matris är flexibla eftersom prenumerationen för den här matrisen inte är i följd eller kan vara negativ eller en sträng i stället för ett tal.

Vanliga frågor och svar

F # 1) Varför använder vi samlingar i PL / SQL?

Svar: Det finns tre typer av samlingar - kapslade tabeller, associerade arrayer och Varrays. De kapslade tabellerna kan lagra ett slumpmässigt antal element. Varrays kan lagra ett fast antal element och de associerande matriserna gör att vi kan söka i element med slumpmässiga siffror och strängar.

F # 2) Vad är den kapslade tabellen i PL / SQL?

Svar: En kapslad tabell har en dimensionell karaktär och dess storlek förblir inte fast. De kan nås i SQL- och PL / SQL-block. Det kan användas i poster, objektdefinitioner och tabeller.

F # 3) Vad är en masssamling i Oracle PL / SQL?

Svar: En bulkinsamling är en metod för att få data när PL / SQL-motorn informerar SQL-motorn att samla flera rader samtidigt och lagra dem i en samling.

Fråga # 4) Varför är bulkuppsamlingen snabbare i Oracle?

Svar: Massuppsamlingen förbättrar prestandan genom att minska interaktionen mellan PL / SQL-motorn och databasen.

F # 5) Vad är Varray i PL / SQL?

Svar: Det är en PL / SQL-datastruktur som används för att lagra en homogen samling av element av samma datatyp i en sekvens. Det används mest för att hålla en beställd uppsättning data.

F # 6) Kan vi ta bort element från Varray i Oracle?

Svar: Vi kan inte ändra eller ta bort element i en Varray med hjälp av SQL-uttalanden direkt. Vi måste välja Varray från tabellen, ändra den i PL / SQL och sedan ändra tabellen och lagra den i en ny Varray.

F # 7) Vad är skillnaden mellan Nested Table och Varray?

Svar: Skillnaderna listas nedan:

  • Vi tar Varray när antalet element är känt från tidigare. Denna begränsning är inte möjlig i kapslade tabeller.
  • I Varray används elementen i sekvens. Det kapslade bordet har både täta och glesa egenskaper.
  • Elementen beställs alltid i Varray. Elementen kan eller inte vara i ordning i den kapslade tabellen.

Slutsats

I denna handledning har vi i detalj diskuterat några av de grundläggande begreppen PL / SQL som är viktiga för att utveckla kunskap om det.

Vi har täckt följande ämnen som listas nedan:

  • Grundläggande förståelse för PL SQL-samlingar (metoder och undantag).
  • Varrays.
  • Kapslade bord
  • Index-by-tabeller

<< PREV Tutorial | NÄSTA självstudie >>

Rekommenderad läsning

^