Jaunu tabulu veidošana no esošajām

Īsti vīri, kā zināms, bekapus (latviski gan būtu rezerves kopijas) netaisa. Un šis arī īsti nebūs raksts par rezerves kopijām to klasiskajā izpratnē, bet par to kā ātri, ērti un vienkārši izveidot kopijas tabulai (-lām) līdz ar visiem datiem, kuru datus Jūs taisaties mainīt vai arī gribat patestēt, vai arī jebkādiem citiem nolūkiem. Un te nu mēs nonākam pie situācijas, kad kārtējo reizi katra DBVS dara tā kā pašai patīk (drīzāk gan jau kā tās izstrādātāji nolēmuši) un vismaz trīs zemāk apskatītajās (Oracle, Microsoft SQL Server un MySQL) katrā tas ir savādāk.

Oracle

Lai izveidotu jaunu tabulu Oracle tiek lietots CREATE TABLE DDL teikums. Tas paliek spēkā arī tad, ja tabula tiek veidota balstoties uz esošu vienu vai vairākām tabulām, t.i., apakšvaicājumu. Tātad ļooooooti vienkāršota sintakse ir šāda:

CREATE TABLE <tabulas nosaukums>
[<kolonu definīcijas>]
[<fiziskie atribūti>]
[<tabulas atribūti>]
AS <apakšvaicājums>

CREATE TABLE <tabulas nosaukums>

Atslēgvārdi CREATE TABLE sāk jebkuras tabulas izveides SQL teikumu. Tālāk tiek rakstīts tabulas nosaukums. Šeit jāatceras, ka Oracle noklusēti visus tabulas nosaukumus un vispār identifikatorus pārvērš uz lielajiem burtiem, tātad datu vārdnīcā Jūsu izveidotā tabula tabulas_nosaukums tiks pārveidota kā TABULAS_NOSAUKUMS. Ja nu Jums vien zināmu iemeslu dēļ tā nevēlaties, tad ir iespējams arī saglabāt tabulas nosaukumu precīzi tādu kā ievadījāt, ja to iekļauj pēdiņās. Piemēram, tabula “manas šausmas $%” tieši tā arī tiks saglabāta datubāzē, taču ar to nekādā ziņā nevajadzētu aizrauties, jo pēc tam Jums vienmēr nāksies nosaukumu rakstīt pēdiņās, kā arī tas ir perfekts veids kā rakstīt neuzturamu kodu. Protams nevajadzētu lietot arī rezervētos vārdus, jo tādu nosaukumu tabulas Oracle neļaus izveidot (ja vien atkal nelietosiet pēdiņas).

<kolonu definīcijas>

Šī daļa ir neobligāta. Pamatā šeit var definēt divas lietas – kolonu nosaukumus un ierobežojumus. Tas, protams, nebūt nav viss iespējamais, bet vairumā gadījumu jo sevišķi šai gadījumā ar to pietiek. Jāņem vērā vairākas lietas:

  • kolonu nosaukumiem jāatbilst pieļaujamiem identifikatoru nosaukumiem Oraclē;
  • kolonu skaitam jāsakrīt ar kolonu skaitu apakšvaicājumā;
  • datu tipu definēt šeit nedrīkst, jo to nosaka apakšvaicājuma atgrieztais rezultāts.

<fiziskie atribūti>

Parasti šeit neko norādīt nevajag, jo visas noklusētās vērtības ir gana labas un pieņemamas. Taču iespēja ir un norādīt var tādas lietas kā:

  • tabultelpu (tablespace);
  • atribūtus ar kādiem, tabula fiziski tiks glabāta (pctfree, pctused u.c.);
  • vai tabula tiks kompresēta (compressed);
  • tabulas veidu (heap – parastā tabula, index organized – glabāta kā indeksa struktūra, external – ārējā), katrai no šiem tabulas veidiem vēl ir milzums atribūti;
  • kādā klāsterī tā tiks glabāta;
  • u.c.

<tabulas atribūti>

Līdzīgi kā iepriekšējā klauza, šī parasti ātrai tabulu izveidošanai nav nepieciešama, taču šeit var norādīt tādas lietas, kā:

  • vai tabula tiks particionēta (partitioned);
  • tabulas paralelitātes atribūtus;
  • vai tabulai tiks glabāta noklusēta kolona (rowdependencies) norādot pēdējo sistēmas izmaiņu kārtas numuru (scn, system change number);
  • iespējot/atspējot ierakstu pārvietošanu (row movement);
  • u.c.

Šo un iepriekšējo klauzu es pieminu tikai tāpēc, lai saprastu, ka principā šeit ir iespējams definēt praktiski visas iespējamās lietas, ko Oracle atļauj CREATE TABLE teikumam. Aptuvenai apjoma sapratnei tās ir 73 lapas no dokumentācijas, kurā iespējas ir pamatā tikai uzskaitītas, nevis sīki apstāstīts, ko katra nozīmē😉

AS <apakšvaicājums>

Šeit grūti ko piebilst – šis var būt jebkurš Select teikums, sākot ar relatīvi vienkāršu Select teikumu, tajā var būt iekļautas kopas operācijas, kā arī nekas nekavē lietot kādu no savienojumu veidiem vai, piemēram, analītiskās funkcijas. Īsumā – visu, ko Jūs spējat Select teikumā sarakstīt, var arī izveidot kā CREATE TABLE AS <apakšveicājums> teikumu. Dažas piezīmes un nelieli triki, kas var kādreiz noderēt:

  • dažkārt ir vēlme izveidot tabulu, kas būtu ar tādām pašām kolonām kā kāda cita (vai citu apvienojums), bet datus tai nepievienot. Savukārt kolonu skaits ir liels un slinkums visas tās pārskaitīt. Tad vienkārši jāpievieno SELECT apakšvaicājumam WHERE klauza, kas visām rindām dod aplamu rezultātu, piemēram, WHERE 1 = 0 (skat. piemēru 2).
  • dažkārt gribas pievienot papildus kolonu ar nedefinētām (NULL) vērtībām, kas SELECT teikumā tieši atlasīta netiek, bet kura tiks vēlāk koriģēta izmantojot UPDATE teikumu. Tādā gadījumā select teikumam vienkārši jāpievieno jauna kolona, kurā atlasam NULL un tipizējam to ar noteiktu funkciju, nodrošinot to, ka kolona ir ar nepieciešamo datu tipu (skat. piemēru 6).

Oracle piemēri

Vispirms izveidosim mazu tabuliņu ar pāris ierakstiem, kas darbosies, kā izejas datu tabula.

CREATE TABLE pilsetas (
  id INTEGER NOT NULL PRIMARY KEY,
  nosaukums VARCHAR(10));
INSERT INTO pilsetas VALUES (1, 'RĪGA');
INSERT INTO pilsetas VALUES (2, 'TALSI');
COMMIT;

Piemērs 1. Izveidojam tabulas struktūras un datu kopiju.
SQL> CREATE TABLE pilsetas_kopija
  2  AS SELECT * FROM pilsetas;
Table created.
SQL> SELECT * FROM pilsetas_kopija;
        ID NOSAUKUMS
---------- ----------
         1 RĪGA
         2 TALSI

Piemērs 2. Izveidojam tikai tabulas struktūras (bez datiem) kopiju.
SQL> CREATE TABLE pilsetas_kopija1
  2  AS SELECT * FROM pilsetas
  3  WHERE 1 = 0;
Table created.
SQL> SELECT * FROM pilsetas_kopija1;
no rows selected

Tabulas kolonām vienmēr ir jābūt precīzi definētām un tās, protams nedrīkst dublēties. Piemēram šis CREATE TABLE teikums nebūs korekts, jo ir pašsavienojums un vairākas reizes ir viena un tā pati kolona.

Piemērs 3. (Ne-)izveidojam kopiju tabulas savienojumam pašam ar sevi.
SQL> CREATE TABLE pilsetas_kopija2
  2  AS SELECT * FROM pilsetas, pilsetas;
AS SELECT * FROM pilsetas, pilsetas
          *
ERROR at line 2:
ORA-00918: column ambiguously defined

Tātad nekas cits neatliek, kā šim (pašsavienojumam un dekarta reizinājumam reizē) kolonu nosaukumus precīzi uzskaitīt: 

Piemērs 4. Izveidojam kopiju tabulas savienojumam pašam ar sevi piešķirot kolonām unikālus nosaukumus.
SQL> CREATE TABLE pilsetas_kopija2
  2    (id1, nosaukums1, id2, nosaukums2)
  3  AS SELECT p1.*, p2.*
  4  FROM pilsetas p1, pilsetas p2;
Table created.
SQL> SELECT * FROM pilsetas_kopija2;
       ID1 NOSAUKUMS1        ID2 NOSAUKUMS2
---------- ---------- ---------- ----------
         1 RĪGA                1 RĪGA
         1 RĪGA                2 TALSI
         2 TALSI               1 RĪGA
         2 TALSI               2 TALSI

Protams nosaukumiem var piešķirt aizstājējvārdus (alias) jau pašā select teikumā, un tad kolonas nosaukums tiks ņemts no tā. Šeit rēķinam kārtas numuru, nosaukumus sakārtojot dilstošā alfabēta secībā:

Piemērs 5. Izveidojam tabulas kopiju pievienojot jaunu kolonu.
SQL> CREATE TABLE pilsetas_kopija3
  2  AS SELECT id, nosaukums,
  3    row_number() OVER (ORDER BY nosaukums desc) kartas_nr
  4  FROM pilsetas;
Table created.
SQL> SELECT * FROM pilsetas_kopija3;
        ID NOSAUKUMS   KARTAS_NR
---------- ---------- ----------
         2 TALSI               1
         1 RĪGA                2

Pēdējais piemērs būs par to kā pievienot jaunas kolonas ar null vērtībām, bet ar korektu datu tipu.

Piemērs 6. Izveidojam tabulas kopiju pievienojot jaunas kolonas ar nedefinētām vērtībām, bet nepieciešamo tipu.
SQL> CREATE TABLE pilsetas_kopija4
  2  AS SELECT id, nosaukums,
  3    CAST(null AS NUMBER(9)) iedz_skaits,
  4    CAST (null AS VARCHAR2(100)) piezimes
  5  FROM pilsetas;
Table created.
SQL> SELECT * FROM pilsetas_kopija4;
        ID NOSAUKUMS  IEDZ_SKAITS PIEZIMES
---------- ---------- ----------- ------------
         1 RĪGA
         2 TALSI
SQL> desc pilsetas_kopija4
 Name               Null?    Type
 ------------------ -------- ------
 ID                 NOT NULL NUMBER(38 )
 NOSAUKUMS                   VARCHAR2(10 CHAR)
 IEDZ_SKAITS                 NUMBER(9)
 PIEZIMES                    VARCHAR2(100)

SQL Server

Līdz šim mana pieredze ar Oracle liecināja, ka var daudzmaz strikti atdalīt Datu definēšanas valodas teikumus (CREATE, ALTER, DROP) no Datu manipulēšanas valodas teikumiem (INSERT, SELECT, UPDATE, MERGE, DELETE). Taču kā izrādās man šī pieredze ir jāpārskata vismaz attiecībā uz SQL Server, jo tur tabulu var izveidot ar SELECT. Tātad šeit tas ir savādāk, kas arī diezgan loģiski, jo taisīja jau cita organizācija ar citiem cilvēkiem ;)

Tātad sintakse jaunas tabulas izveidei no esošajām ir šāda:

SELECT <kolonu definīcijas>
INTO <tabulas nosaukums>
<atlikusī Select teikuma daļa>

SQL Server piemēri

Kā izejas tabulu lietosim to pašu, kas definēta Oracle piemēriem un piemēru funkcionālais rezultāts arī būs tāds pats kā iepriekšējiem, tikai šoreiz SQL Server sintaksē.

Piemērs 7. Izveidojam tabulas struktūras un datu kopiju.
SELECT * INTO pilsetas_kopija
FROM pilsetas;
(2 row(s) affected)
 
SELECT * FROM pilsetas_kopija;
1	RĪGA
2	TALSI

Piemērs 8. Izveidojam tikai tabulas struktūras (bez datiem) kopiju.
SELECT * INTO pilsetas_kopija1
FROM pilsetas
WHERE 1 = 0;
(0 row(s) affected)
 
SELECT * FROM pilsetas_kopija1;
<nav ierakstu, bet vaicājums izpildās parādot, ka tabula izveidota>

Arī SQL serverī protams tabulu kolonu nosaukumiem ir jābūt unikāliem.

Piemērs 9. (Ne-)izveidojam kopiju tabulas savienojumam pašam ar sevi.
SELECT * INTO pilsetas_kopija2
FROM pilsetas, pilsetas;
Msg 1013, Level 16, State 1, Line 1
The objects "pilsetas" and "pilsetas" in the
FROM clause have the same exposed names.
Use correlation names to distinguish them.

Koriģējam Select teikumu, lai kolonu nosaukumi būtu unikāli

Piemērs 10. Izveidojam kopiju tabulas savienojumam pašam ar sevi piešķirot kolonām unikālus nosaukumus.
SELECT p1.id id1, p1.nosaukums nosaukums1,
       p2.id id2, p2.nosaukums nosaukums2
INTO pilsetas_kopija2
FROM pilsetas p1, pilsetas p2;
(4 row(s) affected)
 
SELECT * FROM pilsetas_kopija2;
1	RĪGA	1	RĪGA
2	TALSI	1	RĪGA
1	RĪGA	2	TALSI
2	TALSI	2	TALSI

Līdzīgi varam pieškirt aizstājējvārdus izrēķinātām kolonām:

Piemērs 11. Izveidojam tabulas kopiju pievienojot jaunu kolonu.
SELECT id, nosaukums,
  row_number() OVER (ORDER BY nosaukums desc) kartas_nr
INTO pilsetas_kopija3
FROM pilsetas;
(2 row(s) affected)
 
SELECT * FROM pilsetas_kopija3;
2	TALSI	1
1	RĪGA	2

Pēdējais piemērs būs par to kā pievienot jaunas kolonas ar null vērtībām, bet ar korektu datu tipu.

Piemērs 12. Izveidojam tabulas kopiju pievienojot jaunas kolonas ar nedefinētām vērtībām, bet nepieciešamo tipu.
SELECT id, nosaukums,
  CAST(null AS INTEGER) iedz_skaits,
  CAST (null AS VARCHAR(100)) piezimes
INTO pilsetas_kopija4
FROM pilsetas;
(2 row(s) affected)
 
SELECT * FROM pilsetas_kopija4;
1	RĪGA	NULL	NULL
2	TALSI	NULL	NULL
 
EXEC sp_columns @table_name = 'pilsetas_kopija4'
(daļa no rezultāta)
pilsetas_kopija4	id		int	10
pilsetas_kopija4	nosaukums	varchar	10
pilsetas_kopija4	iedz_skaits	int	10
pilsetas_kopija4	piezimes		varchar	100

MySQL

MySQL principā sintakse ir līdzīgāka Oracle nekā SQL Server, jau ar to vien, ka tas ir CREATE TABLE teikums. MySQL ir diezgan iezīmīga ar to, ka tajā ir iespējami dažādi sintakses paveidi, kas ir specifiski tieši tai un paredzēti relatīvi specifiskam mērķim. Tad nu lūk arī šeit nav izņēmums – ir iespēja izveidot precīzu tabulas struktūras kopiju (bez datiem, bet toties ar visiem ierobežojumiem un indeksiem!) ar konkrētu SQL teikumu, kas paredzēts tikai šim mērķim. Tā sintakse ir šāda:

CREATE TABLE <tabulas nosaukums>
LIKE <vecās tabulas nosaukums>

Savukārt krietni universālākā sintakse ir vēl līdzīgāka Oracle sintaksei:

CREATE TABLE <tabulas nosaukums>
[<kolonu definīcijas>]
[<tabulas atribūti>]
[<particionēšanas atribūti>]
<apakšvaicājums>

Tātad īss apskats, ko katra no šīm klauzām dara:

  • CREATE TABLE <tabulas nosaukums> – kā to viegli saprast norāda jaunās tabulas nosaukumu.
  • <kolonu definīcijas> – neobligāta klauza, pamatā var norādīt klāt pieliekamās kolonas (var nebūt arī apakšvaicājumā!) un to ierobežojumus. Atcerieties, ka MySQL skatās šai klauzā definēto kolonu nosaukumus un salīdzina tos ar apakšvaicājumā atlasītajiem, ja nesakrīt – tad izveido jaunas kolonas. Tas reizē ir gan spēks, gan potenciālas briesmas, jo ir viegli kļūdīties nosaukumā vienā burtā un iegūt gandrīz vienādus kolonu nosaukumus. No otras puses, protams, CREATE TABLE komanda nav tā biežāk izmantojamā.
  • <tabulas atribūti> – norāda dažādas lietas par tabulu, piemēram, tās tabultelpu, veidu u.c.
  • <particionēšanas atribūti> – iespēja norādīt particionētās tabulas atribūtus.

MySQL piemēri

Kā izejas tabulu lietosim to pašu, kas definēta Oracle piemēriem un piemēru funkcionālais rezultāts arī lielākoties būs tāds pats kā iepriekšējiem, tikai šoreiz MySQL sintaksē.

Piemērs 13. Izveidojam tabulas struktūras kopiju izmantojot MySQL specifisko CREATE TABLE..LIKE..
mysql> CREATE TABLE pilsetas_kopija
    -> LIKE pilsetas;
Query OK, 0 rows affected (0.05 sec)
mysql> SELECT * FROM pilsetas_kopija;
Empty set (0.03 sec)
mysql> desc pilsetas_kopija;
+-----------+-------------+------+-----+---------+-------+
| Field     | Type        | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+
| id        | int(11)     | NO   | PRI | NULL    |       |
| nosaukums | varchar(10) | YES  |     | NULL    |       |
+-----------+-------------+------+-----+---------+-------+
2 rows in set (0.08 sec)

Redzam, ka iepriekšējā piemērā ir izveidota arī primārā atslēga.

Piemērs 14. Izveidojam tabulas struktūras un datu kopiju.
mysql> CREATE TABLE pilsetas_kopija1
    -> SELECT * FROM pilsetas;
Query OK, 2 rows affected (0.09 sec)
Records: 2  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM pilsetas_kopija1;
+----+-----------+
| id | nosaukums |
+----+-----------+
|  1 | RIGA      |
|  2 | TALSI     |
+----+-----------+
2 rows in set (0.00 sec)

Nākošajā piemērā izveidosim tabulas struktūras kopiju ar klasisko paņēmienu. Ir vērts pievērst uzmanību, ka šajā gadījumā netiek pārkopēti ierobežojumi – nav izveidots primārās atslēgas ierobežojums. Salīdzinam ar 13. piemēru, kur tas tika izveidots.

Piemērs 15. Izveidojam tabulas struktūras (bez datiem!) kopiju ar klasisko paņēmienu.
mysql> CREATE TABLE pilsetas_kopija2
    -> SELECT * FROM pilsetas
    -> WHERE 1 = 0;
Query OK, 0 rows affected (0.20 sec)
Records: 0  Duplicates: 0  Warnings: 0
mysql> desc pilsetas_kopija2;
+-----------+-------------+------+-----+---------+-------+
| Field     | Type        | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+
| id        | int(11)     | NO   |     | NULL    |       |
| nosaukums | varchar(10) | YES  |     | NULL    |       |
+-----------+-------------+------+-----+---------+-------+
2 rows in set (0.02 sec) 

Arī MySQLā nākošajā piemērā dabūjam kļūdu.

Piemērs 16. (Ne-)izveidojam kopiju tabulas savienojumam pašam ar sevi.
mysql> CREATE TABLE pilsetas_kopija3
    -> SELECT * FROM pilsetas, pilsetas;
ERROR 1066 (42000): Not unique table/alias: 'pilsetas'

Piemērs 17. Izveidojam kopiju tabulas savienojumam pašam ar sevi pieškirot kolonām unikālus nosaukumus.
mysql> CREATE TABLE pilsetas_kopija3
    -> SELECT p1.id id1, p1.nosaukums nosaukums1,
    ->        p2.id id2, p2.nosaukums nosaukums2
    -> FROM pilsetas p1, pilsetas p2;
Query OK, 4 rows affected (0.08 sec)
Records: 4  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM pilsetas_kopija3;
+-----+------------+-----+------------+
| id1 | nosaukums1 | id2 | nosaukums2 |
+-----+------------+-----+------------+
|   1 | RIGA       |   1 | RIGA       |
|   2 | TALSI      |   1 | RIGA       |
|   1 | RIGA       |   2 | TALSI      |
|   2 | TALSI      |   2 | TALSI      |
+-----+------------+-----+------------+
4 rows in set (0.00 sec)

Analītiskās funkcijas MySQLā nav, bet tur var lietot lietotāja definētos mainīgos, kas šad tad var aizstāt kādu daļu no to funkcionalitātes. Konkrētā piemēra ideja ņemta no šejienes.

Piemērs 18. Izveidojam tabulas kopiju pievienojot jaunu kolonu.
mysql> CREATE TABLE pilsetas_kopija4
    -> SELECT id, nosaukums,
    ->   @rownum:=@rownum+1 rownum
    -> FROM (SELECT @rownum:=0) t, pilsetas;
Query OK, 2 rows affected (0.11 sec)
Records: 2  Duplicates: 0  Warnings: 0
mysql> desc pilsetas_kopija4;
+-----------+-------------+------+-----+---------+-------+
| Field     | Type        | Null | Key | Default | Extra |
+-----------+-------------+------+-----+---------+-------+
| id        | int(11)     | NO   |     | NULL    |       |
| nosaukums | varchar(10) | YES  |     | NULL    |       |
| rownum    | bigint(21)  | YES  |     | NULL    |       |
+-----------+-------------+------+-----+---------+-------+
3 rows in set (0.02 sec)
mysql> SELECT * FROM pilsetas_kopija4;
+----+-----------+--------+
| id | nosaukums | rownum |
+----+-----------+--------+
|  1 | RIGA      |      1 |
|  2 | TALSI     |      2 |
+----+-----------+--------+
2 rows in set (0.00 sec)

Diemžēl MySQL ļauj izmantot CAST funkciju tikai dažiem datu tipiem. Taču, lai pievienotu jaunas kolonas, var izmantot citu MySQL iespēju, kas ir pilnīgi atšķirīga no Oracle – kolonas, kas tiek definētas <kolonu definīcijās> tiek meklētas pēc nosaukuma <apakšvaicājumā>. Ja tādas netiek atrastas, tad tās vienkārši tiek izveidotas kā NULL. Atzīstos, ka tas mani dziļi izbrīnīja, un sākumā noveda pamatīgā nesapratnē🙂 Tātad skatamies piemēru:

Piemērs 19. Izveidojam tabulas kopiju definējot divas kolonas zem CREATE TABLE un 2 kolonas apakšvaicājumā. Tabulā kopsummā būs 4 kolonas!
mysql> CREATE TABLE pilsetas_kopija5
    -> (iedz_skaits integer, piezimes varchar(100))
    -> SELECT id, nosaukums
    -> FROM pilsetas;
Query OK, 2 rows affected (0.11 sec)
Records: 2  Duplicates: 0  Warnings: 0
mysql> SELECT * FROM pilsetas_kopija5;
+-------------+----------+----+-----------+
| iedz_skaits | piezimes | id | nosaukums |
+-------------+----------+----+-----------+
|        NULL | NULL     |  1 | RIGA      |
|        NULL | NULL     |  2 | TALSI     |
+-------------+----------+----+-----------+
2 rows in set (0.00 sec)
mysql> desc pilsetas_kopija5;
+-------------+--------------+------+-----+---------+-------+
| Field       | Type         | Null | Key | Default | Extra |
+-------------+--------------+------+-----+---------+-------+
| iedz_skaits | int(11)      | YES  |     | NULL    |       |
| piezimes    | varchar(100) | YES  |     | NULL    |       |
| id          | int(11)      | NO   |     | NULL    |       |
| nosaukums   | varchar(10)  | YES  |     | NULL    |       |
+-------------+--------------+------+-----+---------+-------+
4 rows in set (0.03 sec)

Tālākā lasāmviela

One Response to Jaunu tabulu veidošana no esošajām

  1. Jānis says:

    Vismaz SQL Server kontekstā- manuprāt “tabulas kopija” ir tā nosacīti, jo tiek pārkopēti dati, kolonu tipi, null/not null, bet netiek kopēta tabulas struktūras kopija- piem, indeksi, primārā atslēga, ierobežojumi, utt. ko uzskatītu par neatņemamu tabulas sastāvdaļu normālā gadījumā. tāpat arī, piemēram, aprēķinātās kolonnas tiek pārvērstas par parastām..

Komentēt

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Mainīt )

Twitter picture

You are commenting using your Twitter account. Log Out / Mainīt )

Facebook photo

You are commenting using your Facebook account. Log Out / Mainīt )

Google+ photo

You are commenting using your Google+ account. Log Out / Mainīt )

Connecting to %s

%d bloggers like this: