Fogalmak, szabványok

Reguláris kifejezések

A szövegben történő keresés igen gyakori, alapvető műveletnek számít. Az alapértelmezett keresés (adott töredék keresése a szövegben) gyakran szűknek bizonyul: pl. olyat is meg szeretnénk adni, hogy a sor elején található a szöveg, vagy "lazítani" szeretnénk a feltételeken: tudjuk pl. a szöveg elejét és végét, de a közepe bármi lehet. Vagy egyszerre szeretnénk rákeresni arra, hogy Händel és arra, hogy Haendel. E problémák megoldásaként jelentek meg a reguláris kifejezések (regular expression).

Sajnos nincs mindenki által egységesen elfogadott reguláris kifejezés szabvány, kisebb-nagyobb eltérések vannak. Itt a legfontosabb szabályokat sorolom fel:

  • A reguláris kifejezés felülről kompatibilis a "normál" kereséssel. Ez azt is jelenti, hogy az adott karakterek saját magukra illeszkednek. Pl. ha a "hello" reguláris kifejezésre keresünk rá egy szövegben, akkor pont azt fogja visszaadni eredményül, amit várunk.
  • .: ez tetszőleges karakterre illeszkedik. Pl. a "h.ll." illeszkedik a következőkre: hello, halló, hulló, holló stb.
  • []: szögletes zárójelben sorolhatjuk fel azt, hogy milyen karakterre illeszkedhet. Pl. "h[aou]lló" illeszkedik arra, hogy halló, holló és hulló, de pl. arra nem, hogy helló. Itt szakaszt is megadhatunk, pl. az [a-z] az angol ábécé tetszőleges kisbetűjére illeszkedik.
  • [^]: ha a szögletes zárójelben az első karakter ez: ^, akkor azzal pont azokat soroljuk fel, amire nem illeszkedik. Pl. a "h[^aou]lló" illeszkedik arra, hogy helló, hklló vagy h&lló, de arra nem, hogy hulló.
  • ^ és $: a sor elejére és a sor végére illeszkedik. Pl. az, hogy "^alma$" csak arra a sorra illeszkedik, amely semmi mást nem tartalmaz, csak azt, hogy alma.
  • *, ? és +: ez az előző karakterre vonatkozik, és azt jelezzük, hogy akárhányszor előfordulhat (pl. "ab*c"-re illeszkedik az ac, az abc és az abbbbc is), legfeljebb egyszer fordulhat elő (az "ab?c"-re illeszkedik az ac és az abc, de az abbbc nem), ill. legalább egyszer forduljon elő (pl. az "ab+c"-re illeszkedik az abc és az abbbc is, de az ac nem). A * karaktert sok esetben joker karakternek hívjuk, ami mindenre illeszkedik. A szigorú reguláris kifejezés szerint viszont önmagában helytelen a használata (noha a rendszerek többsége megengedi); ha azt szeretnénk kifejezni, hogy bármire illeszkedjen, akkor valójában a ".*" kifejezést kellene használnunk.
  • {n}, {min,} és {min,max}: kapcsos zárójelben megadhatjuk azt, hogy az előző karakter pontosan, legalább ill. adott intervallumon belül hányszor fordulhat elő. Pl. az "ab{2,4}c" illeszkedik arra, hogy abbbc, de nem illeszkedik az abc-re vagy az abbbbbc-re.
  • (): zárójelbe helyezhetünk egy alkifejezést, és a következő utasítás nem egyetlen karakterre vonatkozik, hanem a teljes zárójelre. Pl. a "(hello){3}" a következőre illeszkedik: hellohellohello.
  • |: logikai kizáró vagy. Pl. a "H(ä|ae)ndel" a következőkre illeszkedik: Händel és Haendel.
  • \: ez az ún. escape karakter, segítségével olyan kifejezést adhatunk meg, amit nomrál billentyűzettel nem tudunk begépelni, mert mást jelentene. Példák:
    • \n: új sor
    • \r: kocsi vissza (a Windows-on megelőzi a \n-t, más rendszereken a \n implicit magában foglalja a \r-t is)
    • \t: tabulátor
    • \xnn: az nn a karakter ASCII kódja, hexadecimális formában. Pl. ha valaki a csengetésre szeretne rákeresni, akkor a \x07-et kell beírnia.

Számos kisebb-nagyobb egyéb, egyedi megoldás létezik még, pl. a Java-ban a \p{Alnum} az alfanumerikus karakterekre illeszkedik. Az angol nyelvű Wikipédia szócikk igen jól összefoglalja a lehetőségeket: https://en.wikipedia.org/wiki/Regular_expression.

Adatok formázása

CSV

HTML

XML

Az XML az eXtensible Markup Language rövidítése, aminek a magyar jelentése kb. az, hogy kiterjeszthető jelölőnyelv (a magyar megfelelőjét sohasem használjuk, kizárólag az angol rövidítést). Jól strukturált, gépi és emberi fogyasztásra egyaránt alkalmas szöveges formátum, ami - ahogy a neve is sugallja - kiterjeszthető. A technológia túl van már élete derekán, újabb technológiák vették át a helyét, mindenekelőtt a sokkal tömörebb JSON. Ugyanakkor még van annyira elterjedt, hogy egy részt érdemes ebben a leírásban rászánni.

Az XML sokan hasonlít a HTML-re (történetileg gyaníthatóan közük van egymáshoz), viszont a kettő között van pár lényeges különbség:

  • A HTML-hez hasonlóan itt is tag-ek vannak.
  • A HTML-hez képest sokkal szigorúbb a felépítése:
    • mindegyik tag-et kötelezően e kell zárni (a HTML-ben vannak kivételek, pl. <br> vagy <li>; az XML-ben ez tilos),
    • a tag-eknek szigorú hierarchiában kell lenniük (pl. az <i></b>szöveg</i></b> itt nemcsak ellenjavallt, hanem tilos),
    • kötelező a gyökér tag (a HTML-ben is elvárt a <html>…</html> felépítés, de a böngészők enélkül is megjelenítik a szöveget).
  • A HTML elsődleges szerepe a megjelenítés, az XML-é az adatok továbbítása. Az XML nem tartalmaz információt az adatok formázásra vonatkozóan.
  • A HTML csak meghatározott tag-eket tartalmazhat, az XML bármilyet.
  • Az XML megőrzi a szóközöket.

Az XML formátum

Lássunk egy példát, és azon keresztül ismerkedjünk meg a szabvánnyal!

<?xml version="1.0"?>
<persons>
    <person id="1">
        <name>Sanyi</name>
        <age>34</age>
        <city>Budapest</city>
    </person>
    <person id="2">
        <name>Kata</name>
        <city>Budapest</city>
    </person>
    <person id="3">
        <name>Pista</name>
        <age>46</age>
        <city>Szeged</city>
    </person>
</persons>

A bevezetőben már szó volt a tag-ekről és a hierarchikus felépítésről; lássunk most további részleteket:

  • A felépítése tartalmazhat egy prológust (pl. <?xml version="1.0"?>), melyben meta információkat adhatunk meg, pl. karakter kódolás.
  • Egy nyitó tag - tartalom - záró tag hármasra elemként hivatkozunk. Angolul ezt node-nak hívjuk (magyarul kb. csúcsnak nevezhetjük, gráfelméleti értelemben).
  • A tag érzékeny a betűméretre (case sensitive), tehát pl. a <person> és a <Person> nem ugyanaz.
  • A fő elemet gyökér elemnek nevezzük (a példában ez a persons).
  • Egy elem tartalmazhat további elemeket (gyermek elemek, pl. person) vagy szöveget (levél elem, pl. name), de lehet üres is (pl. <empty></empty> vagy <empty/>). Az egymásba ágyazás elvben tetszőeges mélységű lehet.
  • Egy elem közvetlen magába foglaló elemét szülőnek (parent), a közvetlen tartalmazottakat gyereknek (child), míg a közös szülővel rendelkező, egymás melletti elemeket testvérnek (sibling) nevezzük. A szülőt, annak szülőjét, és tovbb egészen a gyökérig ősöknek (ancestors), míg a gyerekeket, azok gyerekeit stb. egészen a levelekig leszármazottaknak (descendats) hívjuk.
  • Egy elemnek lehetnek attribútumai (pl. id a person esetén), melyek kulcs-érték párok. Az attribútumokat a nyitó tag-ben kell felsorolni, és az érték mindig string típusú, és ennélfogva kötelező idézőjelekbe tenni. Nincs egyértelmű szabály arra, hogy az adatot attribútumként vagy gyermek elemként tároljuk-e, mindenesetre a túl sok attribútumot érdemes elkerülni.
  • Bizonyos karaktereket nem használhatunk az XML-ben, azokat kódolnunk kell, pl. < (&lt;; a > használható, de ha a &lt;-t használjuk, akkor célszerű ezt használni: &gt;)), & (&amp;, ' (&apos;) és " (&quot;). Egyébként használhatunk ékezetes karaktereket, viszont ez esetben célszerű megadni a prológusban megadni a karakterkódolást.
  • Az elem elnevezésekben célszerű bizonyos karaktereket mellőzni, pl. -, ., :.
  • Megjegyzést a következőképpen fűzhetünk hozzá: <!— Ez egy megjegyzés —>. Megjegyzésen belül nem fordulhat elő két kötőjel.
  • Használhatunk névtereket, melyet kettősponttal (:) választhatunk el a névtől. Pl. ha egy névtér neve nt, akkor egy nyitó tag a következőképpen néz ki: <nt:person>. A névteret a legfelső szinten definiálni kell, pl. <nt:persons xmlns:nt="http://faragocsaba.hu/nt">

További információk:

DOM

A DOM a Document Object Model (dokumentum objektum modell) rövidítése, és az XML logikai felépítésére utal. A DOM segítségével tudjuk bejárni különböző programozási nyelvek segítségével, pl. a Java külső könyvtárak oldalon egy Java megoldást láthatunk a bejárásra. Az alábbi műveleteket lehet segítségével végrehajtani:

  • El lehet indulni a gyökér elemen.
  • Adott elemnek le tudjuk kérni az attribútumait, a gyerek elemeit (ha több ugyanolyan van, akkor tudjuk címezni), a hozzá tartozó szövegeit, valamint a következő testvér elemét.
  • Mindezeket meg is tudjuk változtatni: hozzá tudunk adni, tudunk törölni belőle, ill. meg tudjuk változtatni.

További információt és példákat a következő oldalakon találunk:

XPath

Az XPath segítségével DOM XML lekérdezéseket tudunk végrehajtani anélkül, hogy megvalósítanánk a bejárást. Elterjedt a használata még az automatikus GUI teszteléseknél (pl. Selenium), ahol ez egy lehetséges módja a grafikus elem elérésének a HTML logikai felépítése alapján.

Szintaxis:

  • nodename: az összes, adott nevű elemet adja vissza (meg kell adni azt is, hogy honnan keresse, különben nem működik; ld. lejjebb).
  • /: a gyökértől indul, pl. /persons.
  • []: az adott gyereket választja ki, pl. /persons/person[1]. Ez egyúttal példa a több mélységű kiválasztásra is.
  • : tetszőleges mélységben keres, pl. person.
  • @: ezzel hivatkozunk az attribútumra, pl. /persons/person[@id='2'].
  • .: az aktuális elemet választja ki.
  • ..: a szülő elemet választja ki.

Példák:

  • /persons/person[1]: az első személyt választja ki (a tömb sorszámozása itt 1-től indul).
  • /persons/person[last()]: az utolsó személyt választja ki.
  • /persons/person[position()<3]: az első két személyt választja ki.
  • /persons/person[@id='2']: azt a személyt választja ki, akinek az azonosítója 2.
  • /persons/person[city='Budapest']: azt a személyt választja ki, akinek a lakóhelye Budapest.
  • person[city='Budapest']: ebben az esetben ugyanaz mint az előző. Ha a személyek tetszőleges mélységben lehetnének, akkor ez mindegyiket megtalálná.
  • *[city='Budapest']: ez még általánosabb mint az előző: az összes olyan elemet megtalálja, amelyiknek van city nevű gyermek attribútuma, melynek értéke Budapest.
  • /persons/person[city='Budapest']/name: annak a személynek a nevét választja ki (magát az elemet), akinek a lakóhelye Budapest.
  • /persons/person[city='Budapest']/name/text(): annak a személynek a nevéhez tartozó szöveget választja ki, akinek a lakóhelye Budapest. Ez tehát magát a nevet tartalmazza.

Ennek a leírásnak nem célja az XPath részletes ismertetése, az további további lehetőségeket is tartalmaz. Adott esetben érdemes megismerkedni a rokon technológiákkal: XQuery (az XQuery az XML számára olyan, mint az SQL az adatbázisok számára), XLink, XPointer. Néhány javasolt oldal:

DTD

A DTD a Document Type Definition rövidítése (dokumentum típus definíció). Arról mr volt szó, hogy az XML-ben (majdnem) tetszőleges tag-eket használhatunk, viszont ez túl nagy szabadságot ad. Különösen abban (az egyébként tipikus) esetben, ha az XML-t nem ugyanaz a rendszer állítja elő, mint amelyik feldolgozza, érdemes lerögzíteni egy formátumot, lehetőleg úgy, hogy egy adott XML esetén könnyen ellenőrizni tudjuk azt is, hogy formailag megfelel-e a definíciónak.

Lássunk egy példát! Egészítsük ki a fenti XML-t az alábbi módon:

<?xml version="1.0"?>
<!DOCTYPE persons [
    <!ELEMENT persons (person*)>
    <!ELEMENT person (name,age?,city)>
    <!ATTLIST person id CDATA "0">
    <!ELEMENT name (#PCDATA)>
    <!ELEMENT age (#PCDATA)>
    <!ELEMENT city (#PCDATA)>
]>
<persons>
...
</persons>

A fenti megoldás annyiban nem túl jó, hogy minden egyes XML tartalmazza a teljes DTD-t, ami felesleges. Ehelyett azt külön fájlba tehetjük, és hivatkozhatunk rá. Ebben az esetben az XML fejléce az alábbi:

<?xml version="1.0"?>
<!DOCTYPE persons SYSTEM "example.dtd">
<persons>
...

A DTD-t megvalósító fájl (example.dtd) pedig:

<!ELEMENT persons (person*)>
<!ELEMENT person (name,age?,city)>
<!ATTLIST person id CDATA "0">
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ELEMENT city (#PCDATA)>

Ezzel megadtuk, hogy hogyan kell kinéznie az XML-nek. A szintaxis a következő:

  • Elemek: az <!ELEMENT …> tag-gel tudjuk megadni. Megadásának a következő módjai lehetségesek:
    • <!ELEMENT element-name category>: a kategória lehet pl. EMPTY (üres) vagy ANY (bármi)
    • <!ELEMENT element-name (type)>: itt megadjuk a típusát, pl. <!ELEMENT city (#PCDATA)>. Itt a típus csak #CDATA vagy #PCDATA lehet; a CDATA a character data (karakter adat) rövödítése, a PCDATA pedig a parsed character data (elemzett karakter adat) rövidítése. Tehát csak karakter adatot tudunk megadni, így az életkort is ily módon kell definiálnunk. A CDATA és a PCDATA között az a különbség, hogy a PCDATA elemződik, a CDATA viszont nem. Ezt egy példával illusztrálom: a <name>Gyuri</name> PCDATA-ként azt az elemet jelenti, aminek a neve az, hogy <name>, a tartalma meg az, hogy Gyuri, míg ugyanez CDATA-ként a <name>Gyuri</name> szöveget.
    • <!ELEMENT element-name (content)>: összetett elemek esetén ezzel adjuk meg annak tartalmát. Itt a szokásos joker karaktereket is megadhajtuk. Pl. a <!ELEMENT persons (person*)> a persons elemet definiálja, ami tetszőleges számú preson elemből áll (a tetszőleges számra a * utal). A <!ELEMENT person (name,age?,city)> a person elemet definiálja, ami 3 részből áll: egy kötelező name, egy opcionális age (ld. ?) és egy ugyancsak kötelező city komponensből. Ez utóbbiakat később definiáljuk.
  • Attribútumok: formátuma <!ATTLIST element-name attribute-name attribute-type attribute-value>. Példa: <!ATTLIST person id CDATA "0">; itt a person elem id nevű attribútumát definiáltuk, melyek a típusa CDATA (karakter), alapértelmezett értéke pedig "0" (mivel string a típusa).

Ahogy már oly sokszor volt szó róla, itt sem volt célom az, hogy részletesen bemutassam az összes lehetőséget. További hasznos források az alábbiak.

XSD

Az XSD az XML Schema Definition (XML séma definíció) rövidítése. Ez egy másik validáló eszköz, mellyel meg tudjuk adni az XML formátumát. Az XSD önmagában XML formátumú. Ez tehát a DTD alternatívája. Az XSD bőbeszédűbb ugyan, és kevésbé olvasható, viszont pontosabban definiálhatjuk vele a felépítést, és lényegében kiszorította a DTD-t.

Lássuk a fenti példát XSD formában!

<?xml version="1.0" encoding="UTF-8" ?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">

<xs:element name="persons">
  <xs:complexType>
    <xs:sequence>
      <xs:element name="person" maxOccurs="unbounded">
        <xs:complexType>
          <xs:sequence>
            <xs:element name="name" type="xs:string"/>
            <xs:element name="age" type="xs:positiveInteger" minOccurs="0"/>
            <xs:element name="city" type="xs:string"/>
          </xs:sequence>
          <xs:attribute name="id" type="xs:positiveInteger" use="required"/>
        </xs:complexType>
      </xs:element>
    </xs:sequence>
  </xs:complexType>
</xs:element>

</xs:schema>

Magyarázat:

  • A gyökere a megfelelő névtérrel ellátott <element>.
  • Az elemek megadásához az <element> tag-et használhatjuk.
  • Pontosabb elem típusokat adhatunk meg, pl. <complexType> (összetett típus) vagy sequence (szekvencia).
  • Pontosabb adat típusokat adhatunk meg. pl. az életkor esetén megadhatjuk azt, hogy egy pozitív egész szám kell, hogy legyen (<xs:element name="age" type="xs:positiveInteger" minOccurs="0"/>); ilyet a DTD-ben nem tudtunk csinálni.
  • Az előfordulást is megadhatjuk, sőt, jobban finomhangolhatjuk, mint DTD-ben.
  • Az attribútum megadásához az <attribute> tag-et használjuk, pl. <xs:attribute name="id" type="xs:positiveInteger" use="required"/>.

További hasznos információt a témával kapcsolatban ezeken az oldalakon találunk:

XSL

Arról már volt szó, hogy az XML elsősorban adatok továbbítására alkalmas. Ha meg szeretnénk jeleníteni, akkor a szigorú struktúrájának köszönhetően a böngészők általában kiszínezett, lenyitható és összecsukható faszerkezet formájában jelenítik meg. Ha másképp szeretnénk megjeleníteni, pl. táblázatosan, akkor stílus leírást kell mellékelnünk

Az XSL az eXtensible Stylesheet Language rövidítése, és ez alkalmas arra, hogy megformázzuk az XML-t. Valójában az XSL-t 4 részből áll:

  • XSLT (XSL Transformations), azaz XSL átalakítások; ezzel tudjuk az XML-t más formátummá alakítani, pl. HTML-lé, és ezt nézzük meg ebben a részben.
  • XSL-FO: XML formázások (2013-ban a helyét átvette a CSS3)
  • XPath: XML navigációra szolgál.
  • XQuery: XML lekérdezéseket tudunk végrehajtani.

Lássunk egy példát! Először nyissuk meg a fenti example.xml-t egy böngészőből. A legtöbb esetben lenyitható, összecsukható formában jelenik meg. Most adjunk hozzá egy XSL-t, ami a fenti XML-t formázza meg táblázatosan úgy, hogy csak azokat jeleníti meg, ahol meg van adva az életkor, a településeket külön színnel jelöli, és név szerint sorba rendezi. Ennek a kissé erőltetett formázásnak az az oka, hogy lássuk a lehetőségeket. Az XSL fájl neve example.xsl lesz. Szúrjunk be egy hivatkozást erre az XML fejlécben (example.xml):

<?xml version="1.0"?>
<?xml-stylesheet type="text/xsl" href="example.xsl"?>
<persons>
...
</persons>

Valósítsuk meg az XSL-t a következőképpen:

<?xml version="1.0" encoding="UTF-8"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<html> 
<body>
  <h1>Persons</h1>
  <table>
    <tr>
      <th>Id</th>
      <th>Name</th>
      <th>Age</th>
      <th>City</th>
    </tr>
    <xsl:for-each select="persons/person">
      <xsl:sort select="name"/>
      <xsl:if test="age > 0">
        <tr>
          <td><xsl:value-of select="@id"/></td>
          <td><xsl:value-of select="name"/></td>
          <td><xsl:value-of select="age"/></td>
          <xsl:choose>
            <xsl:when test="city = 'Szeged'">
              <td bgcolor="#ffff00"><xsl:value-of select="city"/></td>
            </xsl:when>
            <xsl:when test="city = 'Budapest'">
              <td bgcolor="#ff00ff"><xsl:value-of select="city"/></td>
            </xsl:when>
            <xsl:otherwise>
              <td><xsl:value-of select="city"/></td>
            </xsl:otherwise>
          </xsl:choose>
        </tr>
      </xsl:if>
    </xsl:for-each>
  </table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>

Töltsük be a böngészőbe ismét az XML-t. Ha mindent jól csináltunk, táblázatosan jeleni meg az adat. (Megjegyzés: nálam csak Internet Explorerben jelent meg az elvárt módon, szóval úgy tűnik, valamit elrontottam.)

Lássuk a példa magyarázatát!

  • A stylesheet tag-gel adjuk meg azt, hogy itt stíluslapról van szó.
  • A template tag-gel jelöljük azt, az XML melyik részére vonatkozik a formázás. A fenti példában a gyökeret adtuk meg (match="/"), agy a teljes XML-re vonatkozik.
  • Ezt követően a standard HTML tag-ek következnek.
  • A value-of tag segítségével le tudjuk kérdezni egy elem értékét. XPath segítéségével tudjuk megadni az elemeket. Itt is a @ karakterrel hivatkozunk az attribútumra (pl. @id).
  • A for-each végigiterál egy tömbön, jelen esetben a persons gyökér elemen belüli person elemeken. Az ezt magába foglaló hivatkozások (pl. value-of-ok) ehhez képes relatív.
  • A sort sorba rendezi az elemeket adott szempont szerint; a példában a név szerint.
  • Az if segítségével megadhatjuk, hogy adott dolgot csak bizonyos feltétel teljesülése esetén jelenítsen meg. Jelene esetben a feltétel az, hogy az életkor nagyobb mint 0, ami kiszűri azokat (is), ahol nincs megadva.
  • A choose … when … otherwise struktúra a más nyelvekben jól ismert switch-case-default XSL megfelelője. A példában sárgára állítjuk azoknak a celláknak a hátterét, amelyek a város oszlopban találhatóak és Szeged szerepel bennük, lilára azokat, melyekben Budapest, és mindegyik más alapértelmezett (fehér) marad.

További források:

JSON

JSONPath

ASN.1

Avro

https://github.com/martijns/AvroViewer

printf

Dátum

yyyy-MM-dd

Crontab

Naplózás

Szám formázás

(Excel)

Üzenetküldés

Gyorsítótár

A gyorsítótár (angolul cache, ejtsd: kes) nagy általánosan megfogalmazva arra szolgál, hogy a lassan, drágán megszerzett adatot egy gyorsan, olcsón hozzáférhető helyen tároljuk el, legtöbbször ideiglenesen. Az, hogy mi a cache, relatív fogalom. Íme pár példa:

  • Való életből vett példa: a böngésző eltárolja a letöltött oldalakat, hogy legközelebb ne terhelje a hálózati kapcsolatot (ami lassú és drága), hanem a lemezről olvassa be (ami gyors és olcsó). Idővel az így ideiglenesen lementett fájl törlődik, egyrészt mert helyet foglal, másrészt mert esetleg lehet neki frissített változata.
  • A programozásból vett példa: ha egy adatbázisból beolvasunk egy adatot, akkor eltároljuk a memóriában, mert esélyes, hogy ugyanazt az adatot ismét ki szeretnénk olvasni, és itt a lassú lemezről olvasás helyett gyorsabb a memóriából beolvasni. Persze a memóriában való tárolás önmagában drága (túl értékes a memória ahhoz, hogy csak "biztos, ami biztos" alapon mindent eltároljunk benne), így néha érdemes üríteni és ismét beolvasni, már amiatt is, mert lehet, hogy közben megváltozott az adat.
  • Hardver példa: a processzor belső memóriájának a mérete eltörpül a számítógép memóriája mellett, viszont az abban tárolt adat sokkal gyorsabban elérhető, így kiválóan alkalmas sokszor használt adat gyorsítótárazására.

A példákból is látható, hogy a cache egy relatív fogalom. Az első esetben a merevlemez volt a cache, a másodikban viszont a merevlemezen levő adat számított lassúnak, és a cache maga a memória volt, a harmadikban pedig a memória volt a lassú, és a processzor belső memóriája a gyors. Az adatbázisos egyébként a klasszikus példa, és ha más nem derül ki a kontextusból, akkor cache alatt ezt szoktuk érteni. A példákat viszont lehetne sorolni: ha egy cédéről merevlemezre másolunk zenét, azt is tkp. cache-eljük; az is tkp. cache-nek számít, ha megszerzünk egy olyan adatot, melyhez nehezen megszerezhető belépési kódra volt szükségünk, a felhőben levő saját tárterületünkre mentjük, ahova folyamatosan be vagyunk lépve.

Többszálúság

A többszálúság során előkerülnek a szinkronizálási problémák, melyekkel kapcsolatos fogalmak az alábbiak:

  • Lock (lakat): adott erőforráshoz egyszerre egyvalaki férhet hozzá, aki a lakatot nyitó kulcsot birtokolja.
  • Monitor: többszálú programok esetén adott eljárás (vagy annak egy része) egyszerre egy szálon belül futhat. Igazából több ilyen egymást is kizárhatja; pl. ha ugyanazt az erőforrást több eljárás is írhatja, akkor egyszerre csak az egyik futhat. Annyiban rokon fogalom a lakattal, hogy a kizárást technikailag lakattal szokás megvalósítani.
  • Mutex (mutual exclusion, kölcsönös kizárás): hasonló a monitorhoz, viszont ezt általában operációs rendszer szinten értjük, tehát két külön program, egy program két példánya, vagy azon belül egy szakasz nem futhat egyszerre, de programon belül több szál is hozzáférhet adott erőforráshoz egyszerre.
  • Semaphore (szemafor): maximálva van a párhuzamosan hozzáférő szálak száma. Ezt tehát általában nem kizárásra, hanem korlátozásra használjuk. Ha a párhuzamos szálak maximális számát 1-re állítjuk, akkor (programon belül gondolkodva) az egyenértékű a monitorral.

Adatbázison belüli problémák

Adat típusok

TODO: Entity, DTO, BO

Hálózat

ETL

Az ETL rövidítés az Extract, Transform, Load szavakból származik, és arra a gyakori folyamatra utal, melynek következtében az adat megérkezik, a rendszer átalakítja, majd megjelenik a kimeneten a módosított adat. A technológia maga a mai értelembe vett számítógépek hőkorába nyúlik vissza, jelentősége viszont a big data megjelenésével és elterjedésével nőtt meg. A Spark keretrendszer tipikus példája a mai modern ETL rendszereknek.

UUID

Az UUID az Universally Unique Identifier, magyarul univerzálisan egyedi azonosító rövidítése. Ahogy a neve is mondja, olyan azonosító generálásáról van szó, ami globálisan egyedi, máshol nem fordul elő. Mindez nem egy központi szerver segítségével történik (ahol el vannak tárolva az eddig kiosztott azonosítók), hanem helyben történik. A generálás figyelembe veszik a rendszeridőt (100 nanoszekundumos intervallum szerint), a hardver MAC címét (ami szintén univerzálisan egyedi), és még véletlen számot is generál, így a szabályosan generált UUID esetén az ütközés valószínűsége gyakorlatilag nulla. Az UUID egy 128 bites szám, amit tipikusan hexadecimálisan tárulunk, és tartalmaz kötőjeleket is, pl. ecb79538-b956-44c6-b3e0-e1ef3d5eda54.

Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License