સમય શ્રેણી અને વધુ માટે વેલા → સ્માર્ટ કેશ

ફિનટેકમાં, અમારે મોટાભાગે ચલણ વિનિમય દરના ડેટાના મોટા પ્રમાણમાં પ્રક્રિયા કરવી પડે છે. અમે વિવિધ સ્ત્રોતોમાંથી ડેટા મેળવીએ છીએ, અને તેમાંના દરેક પાસે આવતી કાલ, આગલા દિવસે, આવતા મહિને અને આગામી ત્રણ વર્ષ માટે વિનિમય દરો કેવી રીતે એક્સ્ટ્રાપોલેટ કરવા તેનો પોતાનો વિચાર છે. જો કોઈ વ્યક્તિ દરોની આગાહી કરી શકે અધિકાર, તે ધંધો બંધ કરવાનો અને માત્ર મૂર્ખતાપૂર્વક પૈસા બદલવાનો સમય હશે. કેટલાક સ્ત્રોતો વધુ વિશ્વસનીય છે, કેટલાક સંપૂર્ણ કચરો પૂરા પાડે છે, જેમાં લગભગ સાચા મૂલ્યોના દુર્લભ સમાવેશ થાય છે, પરંતુ વિદેશી યુગલો માટે. અમારું કાર્ય સેકન્ડ દીઠ આ દસ હજારો મૂલ્યોને તપાસવાનું અને ગ્રાહકોને બરાબર શું બતાવવાનું છે તે નક્કી કરવાનું છે. આપણે ટન ગંદકી અને કાંપમાંથી એક સાચી કિંમત ફિલ્ટર કરવાની જરૂર છે, જેમ ફ્લેમિંગો લંચમાં કરે છે.

ફ્લેમિંગોનું એક વિશિષ્ટ વિશિષ્ટ લક્ષણ તેમની નીચેની તરફ વળેલી ચાંચ છે, જેના વડે તેઓ પાણી અથવા કાદવમાંથી ખોરાકને ફિલ્ટર કરે છે.
 - વિકી

આમ પુસ્તકાલયનો જન્મ થયો 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 આપેલ કી માટે વ્યાખ્યાયિત કરવામાં આવે છે, અથવા ફક્ત સૂચિના મથાળે મૂલ્ય મૂકશે (LIFO, પ્રકરણ જુઓ સortર્ટિંગ નીચે);
• પરિમાણ અનુસાર પંક્તિને ટ્રિમ કરશે :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, અને જ્યારે કોર્સનો નાનો ઇતિહાસ (સમગ્ર શ્રેણી) ની જરૂર હોય, ત્યારે અમે તેને ફક્ત - પહેલાથી જ સૉર્ટ કરેલ - માન્ય મૂલ્યો સાથે પરત કરીએ છીએ.

• GitHub
• હેક્સડોક્સ

હેપી ટાઈમ સીરીઝ કેશીંગ!

સોર્સ: www.habr.com