వేలా → సమయ శ్రేణి మరియు మరిన్నింటి కోసం స్మార్ట్ కాష్

ఫిన్‌టెక్‌లో, మేము తరచుగా కరెన్సీ మార్పిడి రేటు డేటా యొక్క భారీ వాల్యూమ్‌లను ప్రాసెస్ చేయాల్సి ఉంటుంది. మేము వివిధ మూలాల నుండి డేటాను పొందుతాము మరియు వాటిలో ప్రతి ఒక్కటి రేపటి, రేపటి తర్వాత, వచ్చే నెల మరియు తదుపరి మూడు సంవత్సరాలకు ఎక్స్ఛేంజ్ రేట్లను ఎలా ఎక్స్‌ట్రాపోలేట్ చేయాలనే దాని స్వంత ఆలోచనను కలిగి ఉంటుంది. ఎవరైనా రేట్లు అంచనా వేయగలిగితే సరిగ్గా, ఇది వ్యాపారాన్ని మూసివేయడానికి మరియు మూర్ఖంగా డబ్బును ముందుకు వెనుకకు మార్చడానికి సమయం అవుతుంది. కొన్ని మూలాధారాలు మరింత నమ్మదగినవి, కొన్ని పూర్తి చెత్తను సరఫరా చేస్తాయి, దాదాపు సరైన విలువలతో అరుదైన చేరికలు ఉన్నాయి, కానీ అన్యదేశ జంటలకు. సెకనుకు ఈ పదివేల విలువలను జల్లెడ పట్టడం మరియు కస్టమర్లకు సరిగ్గా ఏమి చూపించాలో నిర్ణయించడం మా పని. మధ్యాహ్న భోజనంలో ఫ్లెమింగోలు చేసినట్లే మనం టన్నుల కొద్దీ ధూళి మరియు సిల్ట్ నుండి ఒక సరైన విలువను ఫిల్టర్ చేయాలి.

ఫ్లెమింగోల యొక్క ప్రత్యేక లక్షణం వాటి భారీ క్రిందికి వంగిన ముక్కు, దానితో అవి నీరు లేదా బురద నుండి ఆహారాన్ని ఫిల్టర్ చేస్తాయి.
 - విక్కి

అలా లైబ్రరీ పుట్టింది Vela, ఇది నిర్దిష్ట సమయ వ్యవధిలో బహుళ విలువల కోసం స్టేట్ కాష్‌ను నిల్వ చేస్తుంది. హుడ్ కింద, ఇది ఫ్లైలో చెడు మరియు పాత డేటాను ఫిల్టర్ చేస్తుంది మరియు తాజా వాటికి యాక్సెస్‌ను కూడా అందిస్తుంది N ప్రతి కీ కోసం ధృవీకరించబడిన విలువలు (కరెన్సీ జతలు, మా విషయంలో).

మేము మూడు కరెన్సీ జతలకు రేట్లను సేకరిస్తాము. సరళమైన నిర్వచనం Vela ప్రస్తుత స్థితిని నిల్వ చేయడానికి ఇది ఇలా కనిపిస్తుంది:

defmodule Pairs do
  use Vela,
    eurusd: [sorter: &Kernel.<=/2],
    eurgbp: [limit: 3, errors: 1],
    eurcad: [validator: Pairs]

  @behaviour Vela.Validator

  @impl Vela.Validator
  def valid?(:eurcad, rate), do: rate > 0
end

విలువలను నవీకరిస్తోంది

Vela.put/3 ఫంక్షన్ క్రింది క్రమంలో చేస్తుంది:

• కారణం అవుతుంది validator విలువపై, ఒకటి నిర్వచించబడితే (అధ్యాయం చూడండి ధ్రువీకరణ క్రింద);
• ధృవీకరణ విజయవంతమైతే మంచి విలువల వరుసకు లేదా సేవా వరుసకు విలువను జోడిస్తుంది :__errors__ లేకపోతే;
• ఉంటే సార్టింగ్ కారణం అవుతుంది sorter ఇచ్చిన కీ కోసం నిర్వచించబడింది లేదా జాబితా యొక్క తలపై విలువను ఉంచుతుంది (ఎల్ఐఎఫ్ఓ, అధ్యాయం చూడండి విభజన క్రింద);
• పరామితి ప్రకారం అడ్డు వరుసను ట్రిమ్ చేస్తుంది :limit సృష్టి మీదకు వెళ్ళింది;
• నవీకరించబడిన నిర్మాణాన్ని తిరిగి ఇస్తుంది Vela.

iex|1 > pairs = %Pairs{}
iex|2 > Vela.put(pairs, :eurcad, 1.0)
#⇒ %Pairs{..., eurcad: [1.0], ...}
iex|3 > Vela.put(pairs, :eurcad, -1.0)
#⇒ %Pairs{__errors__: [eurcad: -1.0], ...}
iex|4 > pairs |> Vela.put(:eurusd, 2.0) |> Vela.put(:eurusd, 1.0)
#⇒ %Pairs{... eurusd: [1.0, 2.0]}

కూడా Vela అమలు చేస్తుంది Access, కాబట్టి మీరు విలువలను అప్‌డేట్ చేయడానికి ఆయుధాగారం నుండి నిర్మాణాలను లోతుగా అప్‌డేట్ చేయడానికి ఏదైనా ప్రామాణిక ఫంక్షన్‌లను ఉపయోగించవచ్చు Kernel: Kernel.get_in/2, Kernel.put_in/3, Kernel.update_in/3, Kernel.pop_in/2మరియు Kernel.get_and_update_in/3.

ధ్రువీకరణ

వాలిడేటర్‌ని ఇలా నిర్వచించవచ్చు:

• ఒక వాదనతో బాహ్య ఫంక్షన్ (&MyMod.my_fun/1), ఇది ధృవీకరణ కోసం మాత్రమే విలువను పొందుతుంది;
• రెండు వాదనలతో బాహ్య ఫంక్షన్, &MyMod.my_fun/2, ఆమెకు ఒక జత వస్తుంది serie, value ధ్రువీకరణ కోసం;
• మాడ్యూల్ అమలు Vela.Validator;
• ఆకృతీకరణ పరామితి threshold, మరియు - ఐచ్ఛికంగా - compare_by, అధ్యాయం చూడండి పోలిక క్రింద.

ధ్రువీకరణ విజయవంతమైతే, సంబంధిత కీ క్రింద విలువ జాబితాకు జోడించబడుతుంది; లేకపోతే, టుపుల్ {serie, value} వెళ్ళుటకు :__errors_.

పోలిక

ఈ అడ్డు వరుసలలో నిల్వ చేయబడిన విలువలు ఏదైనా కావచ్చు. నేర్పించడానికి Vela వాటిని పోల్చడానికి, బదిలీ చేయడం అవసరం compare_by సిరీస్ నిర్వచనంలో పరామితి (విలువలను ప్రమాణంతో పోల్చలేకపోతే Kernel.</2); ఈ పరామితి తప్పనిసరిగా రకంగా ఉండాలి (Vela.value() -> number()). డిఫాల్ట్‌గా ఇది సులభం & &1.

అలాగే, మీరు అడ్డు వరుస నిర్వచనానికి పరామితిని పాస్ చేయవచ్చు comparator డెల్టా విలువలను లెక్కించేందుకు (min/max); ఉదాహరణకు, ప్రసారం చేయడం ద్వారా Date.diff/2 పోలికగా, మీరు తేదీల కోసం సరైన డెల్టాలను పొందవచ్చు.

పని చేయడానికి మరొక అనుకూలమైన మార్గం పరామితిని పాస్ చేయడం threshold, ఇది కొత్త విలువ యొక్క గరిష్ట అనుమతించదగిన నిష్పత్తిని నిర్వచిస్తుంది {min, max} విరామం. ఇది శాతంగా పేర్కొనబడినందున, చెక్కు ఉపయోగించబడదు comparatorకానీ ఇప్పటికీ ఉపయోగిస్తుంది compare_by. ఉదాహరణకు, తేదీ సమయాల కోసం థ్రెషోల్డ్ విలువను పేర్కొనడానికి, మీరు తప్పనిసరిగా పేర్కొనాలి compare_by: &DateTime.to_unix/1 (పూర్ణాంకం విలువ పొందడానికి) మరియు threshold: 1, కొత్త విలువలు ఉన్నట్లయితే మాత్రమే అనుమతించబడతాయి ±band ప్రస్తుత విలువల నుండి విరామం.

చివరగా, మీరు ఉపయోగించవచ్చు Vela.equal?/2 రెండు కాష్‌లను పోల్చడానికి. విలువలు ఒక ఫంక్షన్‌ను నిర్వచిస్తే equal?/2 లేదా compare/2, అప్పుడు ఈ ఫంక్షన్లు పోలిక కోసం ఉపయోగించబడతాయి, లేకుంటే మేము తెలివితక్కువగా ఉపయోగిస్తాము ==/2.

విలువలను పొందడం

ప్రస్తుత స్థితిని ప్రాసెస్ చేయడం సాధారణంగా కాలింగ్‌తో ప్రారంభమవుతుంది Vela.purge/1, ఇది వాడుకలో లేని విలువలను తొలగిస్తుంది (ఉంటే validator ముడిపడి ఉంది timestamps) అప్పుడు మీరు కాల్ చేయవచ్చు Vela.slice/1ఇది తిరిగి వస్తుంది keyword అడ్డు వరుస పేర్లను కీలుగా మరియు మొదటి, వాస్తవ విలువలతో.

మీరు కూడా ఉపయోగించవచ్చు get_in/2/pop_in/2 ప్రతి అడ్డు వరుసలోని విలువలకు తక్కువ-స్థాయి యాక్సెస్ కోసం.

అప్లికేషన్

Vela వంటి ప్రక్రియ స్థితిలో సమయ శ్రేణి కాష్‌గా చాలా ఉపయోగకరంగా ఉంటుంది GenServer/Agent. మేము ఎప్పుడూ పాత కోర్సు విలువలను ఉపయోగించకూడదనుకుంటున్నాము మరియు దీన్ని చేయడానికి మేము ప్రాసెస్‌ను స్టేట్‌తో ప్రాసెస్ చేస్తాము Vela, క్రింద చూపబడిన వాలిడేటర్‌తో.

@impl Vela.Validator
def valid?(_key, %Rate{} = rate),
  do: Rate.age(rate) < @death_age

и Vela.purge/1 మనకు డేటా అవసరమైన ప్రతిసారీ అన్ని పాత విలువలను నిశ్శబ్దంగా తొలగిస్తుంది. వాస్తవ విలువలను యాక్సెస్ చేయడానికి మేము కాల్ చేస్తాము Vela.slice/1, మరియు కోర్సు యొక్క చిన్న చరిత్ర (మొత్తం సిరీస్) అవసరమైనప్పుడు, మేము దానిని చెల్లుబాటు అయ్యే విలువలతో - ఇప్పటికే క్రమబద్ధీకరించిన - తిరిగి ఇస్తాము.

• గ్యాలరీలు
• హెక్స్‌డాక్స్

హ్యాపీ టైమ్ సిరీస్ కాషింగ్!

మూలం: www.habr.com