Aracılığıyla paylaş

Eşleme veri akışında veri dönüştürme ifadesi kullanımı

  • Makale

UYGULANANLAR: Azure Data Factory Azure Synapse Analytics

İpucu

Kuruluşlar için hepsi bir arada analiz çözümü olan Microsoft Fabric'te Data Factory'yi deneyin. Microsoft Fabric , veri taşımadan veri bilimine, gerçek zamanlı analize, iş zekasına ve raporlamaya kadar her şeyi kapsar. Yeni bir deneme sürümünü ücretsiz olarak başlatmayı öğrenin!

Veri akışları hem Azure Data Factory'de hem de Azure Synapse Pipelines'da kullanılabilir. Bu makale, eşleme veri akışları için geçerlidir. Dönüştürmeler hakkında yeniyseniz lütfen eşleme veri akışı kullanarak verileri dönüştürme başlıklı giriş makalesine bakın.

Aşağıdaki makalelerde, eşleme veri akışlarında Azure Data Factory ve Azure Synapse Analytics tarafından desteklenen tüm ifadelerin ve işlevlerin kullanımıyla ilgili ayrıntılar sağlanır. Desteklenen her işlev türünün özetleri için aşağıdaki makalelere başvurun:

Tüm işlevlerin alfabetik listesi

Aşağıda eşleme veri akışlarında kullanılabilen tüm işlevlerin alfabetik bir listesi yer alır.

A

abs

abs(<value1> : number) => number

Bir sayının mutlak değeri.

  • abs(-20) -> 20
  • abs(10) -> 10

acos

acos(<value1> : number) => double

Kosinüs ters değeri hesaplar.

  • acos(1) -> 0.0

add

add(<value1> : any, <value2> : any) => any

Dize veya sayı çifti ekler. Gün sayısına tarih ekler. Zaman damgasına süre ekler. Benzer türde bir diziyi diğerine ekler. + işleciyle aynı.

  • add(10, 20) -> 30
  • 10 + 20 -> 30
  • add('ice', 'cream') -> 'icecream'
  • 'ice' + 'cream' + ' cone' -> 'icecream cone'
  • add(toDate('2012-12-12'), 3) -> toDate('2012-12-15')
  • toDate('2012-12-12') + 3 -> toDate('2012-12-15')
  • [10, 20] + [30, 40] -> [10, 20, 30, 40]
  • toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') + (days(1) + hours(2) - seconds(10)) -> toTimestamp('2019-02-04 07:19:18.871', 'yyyy-MM-dd HH:mm:ss.SSS')

addDays

addDays(<date/timestamp> : datetime, <days to add> : integral) => datetime

Tarihe veya zaman damgasına gün ekleme. Tarih için + işleciyle aynı.

  • addDays(toDate('2016-08-08'), 1) -> toDate('2016-08-09')

addMonths

addMonths(<date/timestamp> : datetime, <months to add> : integral, [<value3> : string]) => datetime

Tarihe veya zaman damgasına aylar ekleyin. İsteğe bağlı olarak bir saat dilimi geçirebilirsiniz.

  • addMonths(toDate('2016-08-31'), 1) -> toDate('2016-09-30')
  • addMonths(toTimestamp('2016-09-30 10:10:10'), -1) -> toTimestamp('2016-08-31 10:10:10')

and

and(<value1> : boolean, <value2> : boolean) => boolean

Mantıksal AND işleci. &Aynı

  • and(true, false) -> false
  • true && false -> false

approxDistinctCount

approxDistinctCount(<value1> : any, [ <value2> : double ]) => long

Bir sütun için ayrı değerlerin yaklaşık toplam sayısını alır. İsteğe bağlı ikinci parametre tahmin hatasını denetlemektir.

  • approxDistinctCount(ProductID, .05) => long

array

array([<value1> : any], ...) => array

Bir öğe dizisi oluşturur. Tüm öğeler aynı türde olmalıdır. Hiçbir öğe belirtilmezse, boş bir dize dizisi varsayılandır. [] oluşturma işleciyle aynı.

  • array('Seattle', 'Washington')
  • ['Seattle', 'Washington']
  • ['Seattle', 'Washington'][1]
  • 'Washington'

ascii

ascii(<Input> : string) => number

Giriş karakterinin sayısal değerini döndürür. Giriş dizesinde birden fazla karakter varsa, ilk karakterin sayısal değeri döndürülür

  • ascii('A') -> 65
  • ascii('a') -> 97

asin

asin(<value1> : number) => double

Ters sinüs değerini hesaplar.

  • asin(0) -> 0.0

assertErrorMessages

assertErrorMessages() => map

Anahtar olarak onay kimliğine sahip satır için tüm hata iletilerinin bir haritasını döndürür.

Örnekler

  • assertErrorMessages() => ['assert1': 'This row failed on assert1.', 'assert2': 'This row failed on assert2.']. In this example, at(assertErrorMessages(), 'assert1') would return 'This row failed on assert1.'

associate

reassociate(<value1> : map, <value2> : binaryFunction) => map

Anahtar/değerlerin eşlemini oluşturur. Tüm anahtarlar ve değerler aynı türde olmalıdır. Herhangi bir öğe belirtilmezse, dizenin dize türüne eşlendiği varsayılan değerdir. Oluşturma işleciyle [ -> ] aynı. Anahtarlar ve değerler birbiriyle değiştirilmelidir.

  • associate('fruit', 'apple', 'vegetable', 'carrot' )=> ['fruit' -> 'apple', 'vegetable' -> 'carrot']

at

at(<value1> : array/map, <value2> : integer/key type) => array

Dizi dizinindeki öğesini bulur. Dizin 1 tabanlıdır. Sınır dışı dizin null değerle sonuç verir. Bir anahtar verilen eşlemedeki bir değeri bulur. Anahtar bulunamazsa null döndürür.

  • at(['apples', 'pears'], 1) => 'apples'
  • at(['fruit' -> 'apples', 'vegetable' -> 'carrot'], 'fruit') => 'apples'

atan

atan(<value1> : number) => double

Ters tanjant değerini hesaplar.

  • atan(0) -> 0.0

atan2

atan2(<value1> : number, <value2> : number) => double

Bir düzlemin pozitif x ekseni ile koordinatlar tarafından verilen nokta arasındaki radyan cinsinden açıyı verir.

  • atan2(0, 0) -> 0.0

avg

avg(<value1> : number) => number

Bir sütunun değerlerinin ortalamasını alır.

  • avg(sales)

avgIf

avgIf(<value1> : boolean, <value2> : number) => number

Ölçütlere göre bir sütunun değerlerinin ortalamasını alır.

  • avgIf(region == 'West', sales)

K

between

between(<value1> : any, <value2> : any, <value3> : any) => boolean

İlk değerin diğer iki değer arasında (dahil) olup olmadığını denetler. Sayısal, dize ve tarih saat değerleri karşılaştırılabilir

  • between(10, 5, 24)
  • true
  • between(currentDate(), currentDate() + 10, currentDate() + 20)
  • false

bitwiseAnd

bitwiseAnd(<value1> : integral, <value2> : integral) => integral

Tam sayı türleri arasında Bit Düzeyinde Ve işleci. & işleciyle aynı

  • bitwiseAnd(0xf4, 0xef)
  • 0xe4
  • (0xf4 & 0xef)
  • 0xe4

bitwiseOr

bitwiseOr(<value1> : integral, <value2> : integral) => integral

Tam sayı türleri arasında Bit Düzeyinde Or işleci. | ile aynı operatör

  • bitwiseOr(0xf4, 0xef)
  • 0xff
  • (0xf4 | 0xef)
  • 0xff

bitwiseXor

bitwiseXor(<value1> : any, <value2> : any) => any

Tam sayı türleri arasında Bit Düzeyinde Or işleci. | ile aynı operatör

  • bitwiseXor(0xf4, 0xef)
  • 0x1b
  • (0xf4 ^ 0xef)
  • 0x1b
  • (true ^ false)
  • true
  • (true ^ true)
  • false

blake2b

blake2b(<value1> : integer, <value2> : any, ...) => string

Bit uzunluğu verilen ve 8 ile 512 arasında yalnızca 8'in katları olabilecek değişen ilkel veri türlerinden oluşan sütun kümesinin Blake2 özetini hesaplar. Bir satır için parmak izi hesaplamak için kullanılabilir

  • blake2b(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))
  • 'c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d'

blake2bBinary

blake2bBinary(<value1> : integer, <value2> : any, ...) => binary

Bit uzunluğu verilen ve 8 ile 512 arasında yalnızca 8'in katları olabilecek değişen ilkel veri türlerinden oluşan sütun kümesinin Blake2 özetini hesaplar. Bir satır için parmak izi hesaplamak için kullanılabilir

  • blake2bBinary(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))
  • unHex('c9521a5080d8da30dffb430c50ce253c345cc4c4effc315dab2162dac974711d')

byItem

byItem(<parent column> : any, <column name> : string) => any

Bir yapı veya yapı dizisi içinde bir alt öğe bulun. Birden çok eşleşme varsa, ilk eşleşme döndürülür. Eşleşme yoksa NULL değer döndürür. Döndürülen değerin tür dönüştürme eylemlerinden (? tarih, ? dize ...) biri tarafından dönüştürülmesi gerekir. Tasarım zamanında bilinen sütun adları yalnızca adlarıyla ele alınmalıdır. Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz

  • byItem( byName('customer'), 'orderItems') ? (itemName as string, itemQty as integer)
  • byItem( byItem( byName('customer'), 'orderItems'), 'itemName') ? string

byName

byName(<column name> : string, [<stream name> : string]) => any

Akışta ada göre bir sütun değeri seçer. İkinci bağımsız değişken olarak isteğe bağlı bir akış adı geçirebilirsiniz. Birden çok eşleşme varsa, ilk eşleşme döndürülür. Eşleşme yoksa NULL değer döndürür. Döndürülen değerin tür dönüştürme işlevlerinden (TO_DATE, TO_STRING ...) biri tarafından dönüştürülmesi gerekir. Tasarım zamanında bilinen sütun adları yalnızca adlarıyla ele alınmalıdır. Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz.

  • toString(byName('parent'))
  • toLong(byName('income'))
  • toBoolean(byName('foster'))
  • toLong(byName($debtCol))
  • toString(byName('Bogus Column'))
  • toString(byName('Bogus Column', 'DeriveStream'))

byNames

byNames(<column names> : array, [<stream name> : string]) => any

Akışta ada göre bir sütun dizisi seçin. İkinci bağımsız değişken olarak isteğe bağlı bir akış adı geçirebilirsiniz. Birden çok eşleşme varsa, ilk eşleşme döndürülür. Bir sütun için eşleşme yoksa, çıkışın tamamı NULL değerdir. Döndürülen değer bir tür dönüştürme işlevi (toDate, toString, ...) gerektirir. Tasarım zamanında bilinen sütun adları yalnızca adlarıyla ele alınmalıdır. Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz.

  • toString(byNames(['parent', 'child']))
  • byNames(['parent']) ? string
  • toLong(byNames(['income']))
  • byNames(['income']) ? long
  • toBoolean(byNames(['foster']))
  • toLong(byNames($debtCols))
  • toString(byNames(['a Column']))
  • toString(byNames(['a Column'], 'DeriveStream'))
  • byNames(['orderItem']) ? (itemName as string, itemQty as integer)

byOrigin

byOrigin(<column name> : string, [<origin stream name> : string]) => any

Kaynak akışta ada göre bir sütun değeri seçer. İkinci bağımsız değişken, kaynak akış adıdır. Birden çok eşleşme varsa, ilk eşleşme döndürülür. Eşleşme yoksa NULL değer döndürür. Döndürülen değerin tür dönüştürme işlevlerinden (TO_DATE, TO_STRING ...) biri tarafından dönüştürülmesi gerekir. Tasarım zamanında bilinen sütun adları yalnızca adlarıyla ele alınmalıdır. Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz.

  • toString(byOrigin('ancestor', 'ancestorStream'))

byOrigins

byOrigins(<column names> : array, [<origin stream name> : string]) => any

Akışta ada göre bir sütun dizisi seçer. İkinci bağımsız değişken, kaynağı olan akıştır. Birden çok eşleşme varsa, ilk eşleşme döndürülür. Eşleşme yoksa NULL değer döndürür. Döndürülen değerin tür dönüştürme işlevlerinden biri tarafından dönüştürülmesi gerekir (TO_DATE, TO_STRING ...) Tasarım zamanında bilinen sütun adları yalnızca adlarıyla ele alınmalıdır. Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz.

  • toString(byOrigins(['ancestor1', 'ancestor2'], 'ancestorStream'))

byPath

byPath(<value1> : string, [<streamName> : string]) => any

Akışta ada göre hiyerarşik bir yol bulur. İkinci bağımsız değişken olarak isteğe bağlı bir akış adı geçirebilirsiniz. Böyle bir yol bulunmazsa null döndürür. Tasarım zamanında bilinen sütun adları/yolları yalnızca adlarıyla veya noktalı notasyon yollarıyla ele alınmalıdır. Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz.

  • byPath('grandpa.parent.child') => column

byPosition

byPosition(<position> : integer) => any

Bir sütun değerini akıştaki göreli konumuna (1 tabanlı) göre seçer. Konum sınırların dışındaysa NULL değeri döndürür. Döndürülen değerin tür dönüştürme işlevlerinden biri tarafından dönüştürülmesi gerekir (TO_DATE, TO_STRING ...) Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz.

  • toString(byPosition(1))
  • toDecimal(byPosition(2), 10, 2)
  • toBoolean(byName(4))
  • toString(byName($colName))
  • toString(byPosition(1234))

C

case

case(<condition> : boolean, <true_expression> : any, <false_expression> : any, ...) => any

Değişen koşullara bağlı olarak bir değer veya diğerini uygular. Giriş sayısı eşitse, diğeri son koşul için varsayılan olarak NULL olarak ayarlanır.

  • case(10 + 20 == 30, 'dumbo', 'gumbo') -> 'dumbo'
  • case(10 + 20 == 25, 'bojjus', 'do' < 'go', 'gunchus') -> 'gunchus'
  • isNull(case(10 + 20 == 25, 'bojjus', 'do' > 'go', 'gunchus')) -> true
  • case(10 + 20 == 25, 'bojjus', 'do' > 'go', 'gunchus', 'dumbo') -> 'dumbo'

cbrt

cbrt(<value1> : number) => double

Bir sayının küp kökünü hesaplar.

  • cbrt(8) -> 2.0

ceil

ceil(<value1> : number) => number

Sayıdan küçük olmayan en küçük tamsayıyı döndürür.

  • ceil(-0.1) -> 0

char

char(<Input> : number) => string

Giriş numarasıyla temsil edilen ascii karakterini döndürür. Sayı 256'dan büyükse, sonuç char(sayı % 256) ile eşdeğerdir

  • char(65) -> 'A'
  • char(97) -> 'a'

coalesce

coalesce(<value1> : any, ...) => any

Bir giriş kümesinden ilk null olmayan değeri döndürür. Tüm girişler aynı türde olmalıdır.

  • coalesce(10, 20) -> 10
  • coalesce(toString(null), toString(null), 'dumbo', 'bo', 'go') -> 'dumbo'

collect

collect(<value1> : any) => array

Toplanan gruptaki ifadenin tüm değerlerini bir dizide toplar. Bu işlem sırasında yapılar toplanabilir ve alternatif yapılara dönüştürülebilir. Öğe sayısı, bu gruptaki satır sayısına eşit olur ve null değerler içerebilir. Toplanan öğelerin sayısı az olmalıdır.

  • collect(salesPerson)
  • collect(firstName + lastName))
  • collect(@(name = salesPerson, sales = salesAmount) )

collectUnique

collectUnique(<value1> : any) => array

Toplanan gruptaki ifadenin tüm değerlerini benzersiz bir dizide toplar. Bu işlem sırasında yapılar toplanabilir ve alternatif yapılara dönüştürülebilir. Öğe sayısı, bu gruptaki satır sayısına eşit olur ve null değerler içerebilir. Toplanan öğelerin sayısı az olmalıdır.

  • collect(salesPerson)
  • collect(firstName + lastName))
  • collect(@(name = salesPerson, sales = salesAmount) )

columnNames

columnNames(<value1>columnNames( : string, i><value1> : boolean) = dizi>

Bir akış için tüm çıkış sütunlarının adlarını alır. İlk bağımsız değişken olarak isteğe bağlı bir akış adı geçirebilirsiniz. İkinci bağımsız değişken de isteğe bağlıdır ve varsayılan olarak false değeri kullanılır. İkinci bağımsız değişkeni olarak true()ayarlarsanız, ADF yalnızca şema kayarak sürüklenen sütunları döndürür.

  • columnNames()
  • columnNames('DeriveStream')
  • columnNames('DeriveStream', true())
  • columnNames('', true())

columns

columns([<stream name> : string]) => any

Bir akış için tüm çıkış sütunlarının değerlerini alır. İkinci bağımsız değişken olarak isteğe bağlı bir akış adı geçirebilirsiniz.

  • columns()
  • columns('DeriveStream')

compare

compare(<value1> : any, <value2> : any) => integer

Aynı türdeki iki değeri karşılaştırır. Değer1 < değer2 ise negatif tamsayı, değer1 == değer2 ise 0, değer1 > değer2 ise pozitif değer döndürür.

  • (compare(12, 24) < 1) -> true
  • (compare('dumbo', 'dum') > 0) -> true

concat

concat(<this> : string, <that> : string, ...) => string

Değişken sayıda dizeyi birleştirir. Dizeleri olan + işleciyle aynıdır.

  • concat('dataflow', 'is', 'awesome') -> 'dataflowisawesome'
  • 'dataflow' + 'is' + 'awesome' -> 'dataflowisawesome'
  • isNull('sql' + null) -> true

concatWS

concatWS(<separator> : string, <this> : string, <that> : string, ...) => string

Değişken sayıda dizeyi bir ayırıcı ile birleştirir. İlk parametre ayırıcıdır.

  • concatWS(' ', 'dataflow', 'is', 'awesome') -> 'dataflow is awesome'
  • isNull(concatWS(null, 'dataflow', 'is', 'awesome')) -> true
  • concatWS(' is ', 'dataflow', 'awesome') -> 'dataflow is awesome'

contains

contains(<value1> : array, <value2> : unaryfunction) => boolean

Sağlanan dizideki herhangi bir öğe sağlanan koşulda true olarak değerlendirilirse true döndürür. contains, koşul işlevindeki bir öğeye #item olarak başvuru bekler.

  • contains([1, 2, 3, 4], #item == 3) -> true
  • contains([1, 2, 3, 4], #item > 5) -> false

cos

cos(<value1> : number) => double

Kosinüs değerini hesaplar.

  • cos(10) -> -0.8390715290764524

cosh

cosh(<value1> : number) => double

Bir değerin hiperbolik kosinüsünü hesaplar.

  • cosh(0) -> 1.0

count

count([<value1> : any]) => long

Değerlerin toplam sayısını alır. İsteğe bağlı sütun belirtilirse, sayıdaki NULL değerleri yoksayar.

  • count(custId)
  • count(custId, custName)
  • count()
  • count(iif(isNull(custId), 1, NULL))

countAll

countAll([<value1> : any]) => long

Nulllar dahil olmak üzere değerlerin toplam sayısını alır.

  • countAll(custId)
  • countAll()

countDistinct

countDistinct(<value1> : any, [<value2> : any], ...) => long

Bir sütun kümesinin ayrı değerlerinin toplam sayısını alır.

  • countDistinct(custId, custName)

countAllDistinct

countAllDistinct(<value1> : any, [<value2> : any], ...) => long

Null değerleri de dahil olmak üzere bir sütun kümesinin ayrı değerlerinin toplam sayısını alır.

  • countAllDistinct(custId, custName)

countIf

countIf(<value1> : boolean, [<value2> : any]) => long

Ölçütlere göre değerlerin toplam sayısını alır. İsteğe bağlı sütun belirtilirse, sayıdaki NULL değerlerini yoksayar.

  • countIf(state == 'CA' && commission < 10000, name)

covariancePopulation

covariancePopulation(<value1> : number, <value2> : number) => double

İki sütun arasındaki popülasyon kovaryansını alır.

  • covariancePopulation(sales, profit)

covariancePopulationIf

covariancePopulationIf(<value1> : boolean, <value2> : number, <value3> : number) => double

Ölçütlere göre iki sütunun popülasyon kovaryansını alır.

  • covariancePopulationIf(region == 'West', sales)

covarianceSample

covarianceSample(<value1> : number, <value2> : number) => double

İki sütunun örnek kovaryansını alır.

  • covarianceSample(sales, profit)

covarianceSampleIf

covarianceSampleIf(<value1> : boolean, <value2> : number, <value3> : number) => double

Ölçütlere göre iki sütunun örnek kovaryansını alır.

  • covarianceSampleIf(region == 'West', sales, profit)

crc32

crc32(<value1> : any, ...) => long

Bit uzunluğu verilen ve yalnızca 0(256), 224, 256, 384, 512 değerlerinden oluşan değişen temel veri türlerinden oluşan sütun kümesinin CRC32 karması hesaplanır. Bir satır için parmak izi hesaplamak için kullanılabilir.

  • crc32(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> 3630253689L

cumeDist

cumeDist() => integer

CumeDist işlevi, bir değerin bölümdeki tüm değerlere göre konumunu hesaplar. Sonuç, bölümün sıralanmasında geçerli satırdan önceki veya buna eşit olan satırların, pencere bölümündeki toplam satır sayısına bölünmesidir. Sıralamadaki tüm bağlama değerleri aynı konuma değerlendirilir.

  • cumeDist()

currentDate

currentDate([<value1> : string]) => date

Bu işin çalışmaya başladığı geçerli tarihi alır. İsteğe bağlı bir saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Veri fabrikasının veri merkezinin/bölgesinin yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • currentDate() == toDate('2250-12-31') -> false
  • currentDate('PST') == toDate('2250-12-31') -> false
  • currentDate('America/New_York') == toDate('2250-12-31') -> false

currentTimestamp

currentTimestamp() => timestamp

İş yerel saat dilimiyle çalışmaya başladığında geçerli zaman damgasını alır.

  • currentTimestamp() == toTimestamp('2250-12-31 12:12:12') -> false

currentUTC

currentUTC([<value1> : string]) => timestamp

Geçerli zaman damgasını UTC olarak alır. Geçerli saatinizin küme saat diliminizden farklı bir saat diliminde yorumlanmasını istiyorsanız, 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde isteğe bağlı bir saat dilimi geçirebilirsiniz. Varsayılan olarak geçerli saat dilimidir. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html. UTC saatini farklı bir saat dilimine dönüştürmek için kullanın fromUTC().

  • currentUTC() == toTimestamp('2050-12-12 19:18:12') -> false
  • currentUTC() != toTimestamp('2050-12-12 19:18:12') -> true
  • fromUTC(currentUTC(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true

D

dayOfMonth

dayOfMonth(<value1> : datetime) => integer

Bir tarih verilen ayın gününü alır.

  • dayOfMonth(toDate('2018-06-08')) -> 8

dayOfWeek

dayOfWeek(<value1> : datetime) => integer

Bir tarih verilen haftanın gününü alır. 1 - Pazar, 2 - Pazartesi ..., 7 - Cumartesi.

  • dayOfWeek(toDate('2018-06-08')) -> 6

dayOfYear

dayOfYear(<value1> : datetime) => integer

Bir tarih verilen yılın gününü alır.

  • dayOfYear(toDate('2016-04-09')) -> 100

days

days(<value1> : integer) => long

Gün sayısı için milisaniye cinsinden süre.

  • days(2) -> 172800000L

decode

decode(<Input> : any, <Charset> : string) => binary

Kodlanmış giriş verilerini verilen karakter kümesine göre bir dizeye kodlar. 'US-ASCII', 'ISO-8859-1', 'UTF-8' (varsayılan), 'UTF-16BE', 'UTF-16LE', 'UTF-16LE', 'UTF-16'

  • decode(array(toByte(97),toByte(98),toByte(99)), 'US-ASCII') -> abc

degrees

degrees(<value1> : number) => double

Radyanları dereceye dönüştürür.

  • degrees(3.141592653589793) -> 180

denseRank

denseRank() => integer

Pencerenin sıralama ölçütü yan tümcesinde belirtilen değer grubundaki bir değerin derecesini hesaplar. Sonuç, bölümün sırasına göre geçerli satırdan önceki veya buna eşit olan satır sayısının bir artı değeridir. Değerler dizide boşluk oluşturmaz. Yoğun Sıralama, veriler sıralanmadığında bile çalışır ve değerlerde değişiklik arar.

  • denseRank()

distinct

distinct(<value1> : array) => array

Diziden ayrı bir öğe kümesi döndürür.

  • distinct([10, 20, 30, 10]) => [10, 20, 30]

divide

divide(<value1> : any, <value2> : any) => any

Sayı çiftini böler. İşleçle / aynı.

  • divide(20, 10) -> 2
  • 20 / 10 -> 2

dropLeft

dropLeft(<value1> : string, <value2> : integer) => string

Dizenin solundan en fazla sayıda karakteri kaldırır. İstenen bırakma, dizenin uzunluğunu aşarsa boş bir dize döndürülür.

  • dropLeft('bojjus', 2) => 'jjus'
  • dropLeft('cake', 10) => ''

dropRight

dropRight(<value1> : string, <value2> : integer) => string

Dizenin sağından olabildiğince çok karakter kaldırır. İstenen bırakma, dizenin uzunluğunu aşarsa boş bir dize döndürülür.

  • dropRight('bojjus', 2) => 'bojj'
  • dropRight('cake', 10) => ''

E

encode

encode(<Input> : string, <Charset> : string) => binary

Giriş dizesi verilerini bir karakter kümesine göre ikili olarak kodlar. 'US-ASCII', 'ISO-8859-1', 'UTF-8' (varsayılan), 'UTF-16BE', 'UTF-16LE', 'UTF-16LE', 'UTF-16'

  • encode('abc', 'US-ASCII') -> array(toByte(97),toByte(98),toByte(99))

Giriş dizesi: string, Charset: string) => binary

endsWith

endsWith(<string> : string, <substring to check> : string) => boolean

Dizenin sağlanan dizeyle bitip bitmediğini denetler.

  • endsWith('dumbo', 'mbo') -> true

equals

equals(<value1> : any, <value2> : any) => boolean

Karşılaştırma eşittir işleci. == işleciyle aynı.

  • equals(12, 24) -> false
  • 12 == 24 -> false
  • 'bad' == 'bad' -> true
  • isNull('good' == toString(null)) -> true
  • isNull(null == null) -> true

equalsIgnoreCase

equalsIgnoreCase(<value1> : string, <value2> : string) => boolean

Karşılaştırma, büyük/küçük harf yoksayma işlecine eşittir. => işleciyle <aynıdır.

  • 'abc'<=>'Abc' -> true
  • equalsIgnoreCase('abc', 'Abc') -> true

escape

escape(<string_to_escape> : string, <format> : string) => string

Biçime göre bir dizeden kaçar. Kabul edilebilir biçim için değişmez değerler :'json', 'xml', 'ecmascript', 'html', 'java'.

except

except(<value1> : array, <value2> : array) => array

Bir diziden başka bir yinelenen öğe bırakmadan oluşan bir fark kümesi döndürür.

  • except([10, 20, 30], [20, 40]) => [10, 30]

expr

expr(<expr> : string) => any

Dizeden bir ifade elde edilir. Bu, bu ifadeyi değişmez olmayan bir biçimde yazmakla aynıdır. Bu, parametreleri dize gösterimi olarak geçirmek için kullanılabilir.

  • expr('price * discount') => any

F

factorial

factorial(<value1> : number) => long

Bir sayının faktöriyelini hesaplar.

  • factorial(5) -> 120

false

false() => boolean

Her zaman yanlış bir değer döndürür. 'false' adlı bir sütun varsa işlevini syntax(false()) kullanın.

  • (10 + 20 > 30) -> false
  • (10 + 20 > 30) -> false()

filter

filter(<value1> : array, <value2> : unaryfunction) => array

Sağlanan koşula uymayen öğeleri dizinin dışına filtreler. Filter, koşul işlevindeki bir öğeye #item olarak başvuru bekler.

  • filter([1, 2, 3, 4], #item > 2) -> [3, 4]
  • filter(['a', 'b', 'c', 'd'], #item == 'a' || #item == 'b') -> ['a', 'b']

find

find(<value1> : array, <value2> : unaryfunction) => any

Koşulla eşleşen bir dizideki ilk öğeyi bulun. Dizideki öğeyi #item olarak adresleyebileceğiniz bir filtre işlevi alır. İç içe yerleştirilmiş haritalar için #item_n(#item_1, #item_2...) gösterimini kullanarak üst eşlemelere başvurabilirsiniz.

  • find([10, 20, 30], #item > 10) -> 20
  • find(['azure', 'data', 'factory'], length(#item) > 4) -> 'azure'
  • find([ @( name = 'Daniel', types = [ @(mood = 'jovial', behavior = 'terrific'), @(mood = 'grumpy', behavior = 'bad') ] ), @( name = 'Mark', types = [ @(mood = 'happy', behavior = 'awesome'), @(mood = 'calm', behavior = 'reclusive') ] ) ], contains(#item.types, #item.mood=='happy') /*Filter out the happy kid*/ )
  • @( name = 'Mark', types = [ @(mood = 'happy', behavior = 'awesome'), @(mood = 'calm', behavior = 'reclusive') ] )

first

first(<value1> : any, [<value2> : boolean]) => any

Sütun grubunun ilk değerini alır. ignoreNulls ikinci parametresi atlanırsa false olduğu varsayılır.

  • first(sales)
  • first(sales, false)

flatten

flatten(<array> : array, <value2> : array ..., <value2> : boolean) => array

Diziyi veya dizileri tek bir dizi halinde düzleştirir. Atomik öğe dizileri değiştirilmeden döndürülür. Son bağımsız değişken isteğe bağlıdır ve özyinelemeli olarak birden fazla düzeyde derin düzleştirme için varsayılan olarak false olarak ayarlanır.

  • flatten([['bojjus', 'girl'], ['gunchus', 'boy']]) => ['bojjus', 'girl', 'gunchus', 'boy']
  • flatten([[['bojjus', 'gunchus']]] , true) => ['bojjus', 'gunchus']

floor

floor(<value1> : number) => number

Sayıdan büyük olmayan en büyük tamsayıyı döndürür.

  • floor(-0.1) -> -1

fromBase64

fromBase64(<value1> : string, <encoding type> : string) => string

Verilen base64 kodlanmış dizenin kodunu çözer. İsteğe bağlı olarak kodlama türünü geçirebilirsiniz.

  • fromBase64('Z3VuY2h1cw==') -> 'gunchus'
  • fromBase64('SGVsbG8gV29ybGQ=', 'Windows-1252') -> 'Hello World'

fromUTC

fromUTC(<value1> : timestamp, [<value2> : string]) => timestamp

UTC'den zaman damgasına dönüştürür. İsteğe bağlı olarak saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Varsayılan olarak geçerli saat dilimidir. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • fromUTC(currentTimestamp()) == toTimestamp('2050-12-12 19:18:12') -> false
  • fromUTC(currentTimestamp(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true

G

greater

greater(<value1> : any, <value2> : any) => boolean

Karşılaştırma büyüktür işleci. İşleçle > aynı.

  • greater(12, 24) -> false
  • ('dumbo' > 'dum') -> true
  • (toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS') > toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> true

greaterOrEqual

greaterOrEqual(<value1> : any, <value2> : any) => boolean

Karşılaştırma büyüktür veya eşittir işleci. = işleciyle >aynıdır.

  • greaterOrEqual(12, 12) -> true
  • ('dumbo' >= 'dum') -> true

greatest

greatest(<value1> : any, ...) => any

Null değerleri atlayan giriş olarak değer listesi arasındaki en büyük değeri döndürür. Tüm girişler null ise null döndürür.

  • greatest(10, 30, 15, 20) -> 30
  • greatest(10, toInteger(null), 20) -> 20
  • greatest(toDate('2010-12-12'), toDate('2011-12-12'), toDate('2000-12-12')) -> toDate('2011-12-12')
  • greatest(toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS'), toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS')) -> toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS')

H

hasColumn

hasColumn(<column name> : string, [<stream name> : string]) => boolean

Akıştaki bir sütun değerini ada göre denetler. İkinci bağımsız değişken olarak isteğe bağlı bir akış adı geçirebilirsiniz. Tasarım zamanında bilinen sütun adları yalnızca adlarıyla ele alınmalıdır. Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz.

  • hasColumn('parent')

hasError

hasError([<value1> : string]) => boolean

Sağlanan kimlikle onayın hata olarak işaretlenip işaretlenmediğini denetler.

Örnekler

  • hasError('assert1')
  • hasError('assert2')

hasPath

hasPath(<value1> : string, [<streamName> : string]) => boolean

Akışta ada göre belirli bir hiyerarşik yol olup olmadığını denetler. İkinci bağımsız değişken olarak isteğe bağlı bir akış adı geçirebilirsiniz. Tasarım zamanında bilinen sütun adları/yolları yalnızca adlarıyla veya noktalı notasyon yollarıyla ele alınmalıdır. Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz.

  • hasPath('grandpa.parent.child') => boolean

hex

hex(<value1>: binary) => string

İkili değerin onaltılık dize gösterimini döndürür

  • hex(toBinary([toByte(0x1f), toByte(0xad), toByte(0xbe)])) -> '1fadbe'

hour

hour(<value1> : timestamp, [<value2> : string]) => integer

Zaman damgasının saat değerini alır. İsteğe bağlı bir saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • hour(toTimestamp('2009-07-30 12:58:59')) -> 12
  • hour(toTimestamp('2009-07-30 12:58:59'), 'PST') -> 12

hours

hours(<value1> : integer) => long

Saat sayısı için milisaniye cinsinden süre.

  • hours(2) -> 7200000L

I

iif

iif(<condition> : boolean, <true_expression> : any, [<false_expression> : any]) => any

Bir koşula bağlı olarak bir değer veya diğerini uygular. Diğer belirtilmemişse NULL olarak kabul edilir. Her iki değer de uyumlu olmalıdır (sayısal, dize...).

  • iif(10 + 20 == 30, 'dumbo', 'gumbo') -> 'dumbo'
  • iif(10 > 30, 'dumbo', 'gumbo') -> 'gumbo'
  • iif(month(toDate('2018-12-01')) == 12, 345.12, 102.67) -> 345.12

iifNull

iifNull(<value1> : any, [<value2> : any], ...) => any

İki veya daha fazla giriş verilip ilk null olmayan öğeyi döndürür. Bu işlev birleşime eşdeğerdir.

  • iifNull(10, 20) -> 10
  • iifNull(null, 20, 40) -> 20
  • iifNull('azure', 'data', 'factory') -> 'azure'
  • iifNull(null, 'data', 'factory') -> 'data'

in

in(<array of items> : array, <item to find> : any) => boolean

Bir öğenin dizide olup olmadığını denetler.

  • in([10, 20, 30], 10) -> true
  • in(['good', 'kid'], 'bad') -> false

initCap

initCap(<value1> : string) => string

Her sözcüğün ilk harfini büyük harfe dönüştürür. Sözcükler boşlukla ayrılmış olarak tanımlanır.

  • initCap('cool iceCREAM') -> 'Cool Icecream'

instr

instr(<string> : string, <substring to find> : string) => integer

Bir dize içindeki alt dizenin konumunu (1 tabanlı) bulur. 0, bulunamazsa döndürülür.

  • instr('dumbo', 'mbo') -> 3
  • instr('microsoft', 'o') -> 5
  • instr('good', 'bad') -> 0

intersect

intersect(<value1> : array, <value2> : array) => array

2 diziden ayrı öğelerden oluşan bir kesişim kümesi döndürür.

  • intersect([10, 20, 30], [20, 40]) => [20]

isBitSet

isBitSet (<value1> : array, <value2>:integer ) => boolean

Bu bit kümesinde bir bit konumunun ayarlandığını denetler

  • isBitSet(toBitSet([10, 32, 98]), 10) => true

isBoolean

isBoolean(<value1>: string) => boolean

Dize değerinin kurallarına göre boole değeri olup olmadığını denetler toBoolean()

  • isBoolean('true') -> true
  • isBoolean('no') -> true
  • isBoolean('microsoft') -> false

isByte

isByte(<value1> : string) => boolean

Dize değerinin kurallarına göre isteğe bağlı bir biçim verilen bir bayt değeri olup olmadığını denetler toByte()

  • isByte('123') -> true
  • isByte('chocolate') -> false

isDate

isDate (<value1> : string, [<format>: string]) => boolean

İsteğe bağlı bir giriş tarihi biçimi kullanarak giriş tarihi dizesinin tarih olup olmadığını denetler. Kullanılabilir biçimler için Java'nın SimpleDateFormat bölümüne bakın. Giriş tarihi biçimi atlanırsa, varsayılan biçim olur yyyy-[M]M-[d]d. Kabul edilen biçimler şunlardır: [ yyyy, yyyy-[M]M, yyyy-[M]M-[d]d, yyyy-[M]M-[d]dT* ]

  • isDate('2012-8-18') -> true
  • isDate('12/18--234234' -> 'MM/dd/yyyy') -> false

isDecimal

isDecimal (<value1> : string) => boolean

Dize değerinin, kurallarına göre isteğe bağlı bir biçim verilen ondalık değer olup olmadığını denetler toDecimal()

  • isDecimal('123.45') -> true
  • isDecimal('12/12/2000') -> false

isDelete

isDelete([<value1> : integer]) => boolean

Satırın silme için işaretlenip işaretlenmediğini denetler. Birden fazla giriş akışı alan dönüştürmeler için akışın (1 tabanlı) dizinini geçirebilirsiniz. Akış dizini 1 veya 2, varsayılan değer ise 1 olmalıdır.

  • isDelete()
  • isDelete(1)

isDistinct

isDistinct(<value1> : any , <value1> : any) => boolean

Bir sütunun veya sütun kümesinin ayrı olup olmadığını bulur. Null değerini ayrı bir değer olarak saymıyor

  • isDistinct(custId, custName) => boolean

isDouble

isDouble (<value1> : string, [<format>: string]) => boolean

Dize değerinin, kurallarına göre isteğe bağlı bir biçim verilen çift değer olup olmadığını denetler toDouble()

  • isDouble('123') -> true
  • isDouble('$123.45' -> '$###.00') -> true
  • isDouble('icecream') -> false

isError

isError([<value1> : integer]) => boolean

Satırın hata olarak işaretlenip işaretlenmediğini denetler. Birden fazla giriş akışı alan dönüştürmeler için akışın (1 tabanlı) dizinini geçirebilirsiniz. Akış dizini 1 veya 2, varsayılan değer ise 1 olmalıdır.

  • isError()
  • isError(1)

isFloat

isFloat (<value1> : string, [<format>: string]) => boolean

Dize değerinin, kurallarına göre isteğe bağlı bir biçim verildiğinde float değeri olup olmadığını denetler toFloat()

  • isFloat('123') -> true
  • isFloat('$123.45' -> '$###.00') -> true
  • isFloat('icecream') -> false

isIgnore

isIgnore([<value1> : integer]) => boolean

Satırın yoksayılmak üzere işaretlenip işaretlenmediğini denetler. Birden fazla giriş akışı alan dönüştürmeler için akışın (1 tabanlı) dizinini geçirebilirsiniz. Akış dizini 1 veya 2, varsayılan değer ise 1 olmalıdır.

  • isIgnore()
  • isIgnore(1)

isInsert

isInsert([<value1> : integer]) => boolean

Satırın ekleme için işaretlenip işaretlenmediğini denetler. Birden fazla giriş akışı alan dönüştürmeler için akışın (1 tabanlı) dizinini geçirebilirsiniz. Akış dizini 1 veya 2, varsayılan değer ise 1 olmalıdır.

  • isInsert()
  • isInsert(1)

isInteger

isInteger (<value1> : string, [<format>: string]) => boolean

Dize değerinin, kurallarına göre isteğe bağlı bir biçim verilen bir tamsayı değeri olup olmadığını denetler toInteger()

  • isInteger('123') -> true
  • isInteger('$123' -> '$###') -> true
  • isInteger('microsoft') -> false

isLong

isLong (<value1> : string, [<format>: string]) => boolean

Dize değerinin, kurallarına göre isteğe bağlı bir biçim verildiğinde uzun bir değer olup olmadığını denetler toLong()

  • isLong('123') -> true
  • isLong('$123' -> '$###') -> true
  • isLong('gunchus') -> false

isMatch

isMatch([<value1> : integer]) => boolean

Arama sırasında satırın eşleşip eşleşmediğini denetler. Birden fazla giriş akışı alan dönüştürmeler için akışın (1 tabanlı) dizinini geçirebilirsiniz. Akış dizini 1 veya 2, varsayılan değer ise 1 olmalıdır.

  • isMatch()
  • isMatch(1)

isNan

isNan (<value1> : integral) => boolean

Bunun bir sayı olup olmadığını denetleyin.

  • isNan(10.2) => false

isNull

isNull(<value1> : any) => boolean

Değerin NULL olup olmadığını denetler.

  • isNull(NULL()) -> true
  • isNull('') -> false

isShort

isShort (<value1> : string, [<format>: string]) => boolean

Dize değerinin kurallarına göre isteğe bağlı bir biçim verildiğinde kısa bir değer olup olmadığını denetler toShort()

  • isShort('123') -> true
  • isShort('$123' -> '$###') -> true
  • isShort('microsoft') -> false

isTimestamp

isTimestamp (<value1> : string, [<format>: string]) => boolean

İsteğe bağlı bir giriş zaman damgası biçimi kullanarak giriş tarihi dizesinin bir zaman damgası olup olmadığını denetler. Kullanılabilir biçimler için Java'nın SimpleDateFormat bölümüne bakın. Zaman damgası atlanırsa varsayılan desen yyyy-[M]M-[d]d hh:mm:ss[.f...] kullanılır. İsteğe bağlı bir saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Zaman damgası, 999 değeriyle milisaniyeye kadar doğruluğu destekler. Kullanılabilir biçimler için Java'nın SimpleDateFormat dosyasına bakın.

  • isTimestamp('2016-12-31 00:12:00') -> true
  • isTimestamp('2016-12-31T00:12:00' -> 'yyyy-MM-dd\\'T\\'HH:mm:ss' -> 'PST') -> true
  • isTimestamp('2012-8222.18') -> false

isUpdate

isUpdate([<value1> : integer]) => boolean

Satırın güncelleştirme için işaretlenip işaretlenmediğini denetler. Birden fazla giriş akışı alan dönüştürmeler için akışın (1 tabanlı) dizinini geçirebilirsiniz. Akış dizini 1 veya 2, varsayılan değer ise 1 olmalıdır.

  • isUpdate()
  • isUpdate(1)

isUpsert

isUpsert([<value1> : integer]) => boolean

Satırın ekleme için işaretlenip işaretlenmediğini denetler. Birden fazla giriş akışı alan dönüştürmeler için akışın (1 tabanlı) dizinini geçirebilirsiniz. Akış dizini 1 veya 2, varsayılan değer ise 1 olmalıdır.

  • isUpsert()
  • isUpsert(1)

J

jaroWinkler

jaroWinkler(<value1> : string, <value2> : string) => double

İki dize arasındaki JaroWinkler mesafesini alır.

  • jaroWinkler('frog', 'frog') => 1.0

K

keyValues

keyValues(<value1> : array, <value2> : array) => map

Anahtar/değerlerin eşlemini oluşturur. İlk parametre bir anahtar dizisi, ikincisi ise değer dizisidir. Her iki dizi de eşit uzunlukta olmalıdır.

  • keyValues(['bojjus', 'appa'], ['gunchus', 'ammi']) => ['bojjus' -> 'gunchus', 'appa' -> 'ammi']

kurtosis

kurtosis(<value1> : number) => double

Bir sütunun basıklıklarını alır.

  • kurtosis(sales)

kurtosisIf

kurtosisIf(<value1> : boolean, <value2> : number) => double

Ölçütlere göre bir sütunun basıklıklarını alır.

  • kurtosisIf(region == 'West', sales)

L

lag

lag(<value> : any, [<number of rows to look before> : number], [<default value> : any]) => any

Geçerli satırdan önce değerlendirilen ilk parametrenin n satırının değerini alır. İkinci parametre, geriye bakacak satır sayısıdır ve varsayılan değer 1'dir. Çok fazla satır yoksa, varsayılan değer belirtilmediği sürece null değeri döndürülür.

  • lag(amount, 2)
  • lag(amount, 2000, 100)

last

last(<value1> : any, [<value2> : boolean]) => any

Sütun grubunun son değerini alır. ignoreNulls ikinci parametresi atlanırsa false olduğu varsayılır.

  • last(sales)
  • last(sales, false)

lastDayOfMonth

lastDayOfMonth(<value1> : datetime) => date

Verilen tarihin ayın son tarihini alır.

  • lastDayOfMonth(toDate('2009-01-12')) -> toDate('2009-01-31')

lead

lead(<value> : any, [<number of rows to look after> : number], [<default value> : any]) => any

Geçerli satırdan sonra değerlendirilen ilk parametrenin n satırının değerini alır. İkinci parametre, ileriye bakacak satır sayısıdır ve varsayılan değer 1'dir. Çok fazla satır yoksa, varsayılan değer belirtilmediği sürece null değeri döndürülür.

  • lead(amount, 2)
  • lead(amount, 2000, 100)

least

least(<value1> : any, ...) => any

Karşılaştırma küçük veya eşittir işleci. = işleciyle <aynıdır.

  • least(10, 30, 15, 20) -> 10
  • least(toDate('2010-12-12'), toDate('2011-12-12'), toDate('2000-12-12')) -> toDate('2000-12-12')

left

left(<string to subset> : string, <number of characters> : integral) => string

Dizin 1'de karakter sayısıyla bir alt dize başlangıcı ayıklar. SUBSTRING(str, 1, n) ile aynıdır.

  • left('bojjus', 2) -> 'bo'
  • left('bojjus', 20) -> 'bojjus'

length

length(<value1> : string) => integer

Dizenin uzunluğunu döndürür.

  • length('dumbo') -> 5

lesser

lesser(<value1> : any, <value2> : any) => boolean

Karşılaştırma az işleci. İşleçle < aynı.

  • lesser(12, 24) -> true
  • ('abcd' < 'abc') -> false
  • (toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') < toTimestamp('2019-02-05 08:21:34.890', 'yyyy-MM-dd HH:mm:ss.SSS')) -> true

lesserOrEqual

lesserOrEqual(<value1> : any, <value2> : any) => boolean

Karşılaştırma küçük veya eşittir işleci. = işleciyle <aynıdır.

  • lesserOrEqual(12, 12) -> true
  • ('dumbo' <= 'dum') -> false

levenshtein

levenshtein(<from string> : string, <to string> : string) => integer

İki dize arasındaki levenshtein mesafesini alır.

  • levenshtein('boys', 'girls') -> 4

like

like(<string> : string, <pattern match> : string) => boolean

Desen, tam anlamıyla eşleşen bir dizedir. Özel durumlar şu özel simgelerdir: _ girişteki herhangi bir karakterle eşleşir (normal ifadelerde posix öğesine benzer) % değeri girişteki sıfır veya daha fazla karakterle eşleşir (normal ifadelerdeki posix .* karakterine benzer). Kaçış karakteri : ''. Bir kaçış karakteri özel bir simgeden veya başka bir kaçış karakterinden önce gelirse, aşağıdaki karakter kelimenin tam anlamıyla eşleştirilir. Başka bir karakterden kaçmak geçersiz.

  • like('icecream', 'ice%') -> true

locate

locate(<substring to find> : string, <string> : string, [<from index - 1-based> : integral]) => integer

Belirli bir konumdan başlayan bir dize içindeki alt dizenin konumunu (1 tabanlı) bulur. Konum atlanırsa, dizenin başından itibaren dikkate alınır. 0, bulunamazsa döndürülür.

  • locate('mbo', 'dumbo') -> 3
  • locate('o', 'microsoft', 6) -> 7
  • locate('bad', 'good') -> 0

log

log(<value1> : number, [<value2> : number]) => double

Günlük değerini hesaplar. İsteğe bağlı bir taban, kullanılıyorsa başka bir Euler numarası sağlanabilir.

  • log(100, 10) -> 2

log10

log10(<value1> : number) => double

Günlük değerini 10 tabana göre hesaplar.

  • log10(100) -> 2

lookup

lookup(key, key2, ...) => complex[]

Önbelleğe alınan havuzdaki anahtarlarla eşleşen belirtilen anahtarları kullanarak önbelleğe alınan havuzdaki ilk satırı arar.

  • cacheSink#lookup(movieId)

lower

lower(<value1> : string) => string

Dizeyi küçük harfle küçük harfe ekler.

  • lower('GunChus') -> 'gunchus'

lpad

lpad(<string to pad> : string, <final padded length> : integral, <padding> : string) => string

Belirtilen uzunlukta olana kadar sağlanan doldurma tarafından dizeyi sol tuşa koyar. Dize uzunluğuna eşit veya ondan büyükse, uzunluğa kırpılır.

  • lpad('dumbo', 10, '-') -> '-----dumbo'
  • lpad('dumbo', 4, '-') -> 'dumb'

ltrim

ltrim(<string to trim> : string, [<trim characters> : string]) => string

Sol, baştaki karakterlerden oluşan bir dizeyi kırpıyor. İkinci parametre belirtilmemişse, boşluğu kırpar. Aksi halde, ikinci parametrede belirtilen herhangi bir karakteri kırpıyor.

  • ltrim(' dumbo ') -> 'dumbo '
  • ltrim('!--!du!mbo!', '-!') -> 'du!mbo!'

M

map

map(<value1> : array, <value2> : unaryfunction) => any

Sağlanan ifadeyi kullanarak dizinin her öğesini yeni bir öğeyle eşler. Map, ifade işlevindeki bir öğeye #item olarak başvuru bekler.

  • map([1, 2, 3, 4], #item + 2) -> [3, 4, 5, 6]
  • map(['a', 'b', 'c', 'd'], #item + '_processed') -> ['a_processed', 'b_processed', 'c_processed', 'd_processed']

mapAssociation

mapAssociation(<value1> : map, <value2> : binaryFunction) => array

Anahtarları yeni değerlerle ilişkilendirerek haritayı dönüştürür. Bir dizi döndürür. Öğeyi #key ve geçerli değeri #value olarak adresleyebileceğiniz bir eşleme işlevi alır.

  • mapAssociation(['bojjus' -> 'gunchus', 'appa' -> 'ammi'], @(key = #key, value = #value)) => [@(key = 'bojjus', value = 'gunchus'), @(key = 'appa', value = 'ammi')]

mapIf

mapIf (<value1> : array, <value2> : binaryfunction, <value3>: binaryFunction) => any

Bir diziyi aynı veya daha küçük uzunlukta başka bir diziye koşullu olarak eşler. Değerler, structTypes da dahil olmak üzere herhangi bir veri türüne ait olabilir. Dizideki öğeyi #item ve geçerli dizini #index olarak adresleyebileceğiniz bir eşleme işlevi alır. İç içe yerleştirilmiş haritalar için gösterimi kullanarak üst haritalara #item_[n](#item_1, #index_1...) başvurabilirsiniz.

  • mapIf([10, 20, 30], #item > 10, #item + 5) -> [25, 35]
  • mapIf(['icecream', 'cake', 'soda'], length(#item) > 4, upper(#item)) -> ['ICECREAM', 'CAKE']

mapIndex

mapIndex(<value1> : array, <value2> : binaryfunction) => any

Sağlanan ifadeyi kullanarak dizinin her öğesini yeni bir öğeyle eşler. Map, ifade işlevindeki bir öğeye #item ve öğe dizinine #index olarak başvuru bekler.

  • mapIndex([1, 2, 3, 4], #item + 2 + #index) -> [4, 6, 8, 10]

mapLoop

mapLoop(<value1> : integer, <value2> : unaryfunction) => any

Bu uzunlukta bir dizi oluşturmak için 1'den uzunluğa kadar döngüler. Dizideki dizini #index olarak adresleyebileceğiniz bir eşleme işlevi alır. İç içe yerleştirilmiş haritalar için #index_n(#index_1, #index_2...) gösterimini kullanarak üst haritalara başvurabilirsiniz.

  • mapLoop(3, #index * 10) -> [10, 20, 30]

max

max(<value1> : any) => any

Bir sütunun en büyük değerini alır.

  • max(sales)

maxIf

maxIf(<value1> : boolean, <value2> : any) => any

Ölçütlere göre bir sütunun en yüksek değerini alır.

  • maxIf(region == 'West', sales)

md5

md5(<value1> : any, ...) => string

Değişen ilkel veri türlerinden oluşan sütun kümesinin MD5 özetini hesaplar ve 32 karakterlik onaltılık bir dize döndürür. Bir satır için parmak izi hesaplamak için kullanılabilir.

  • md5(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> '4ce8a880bd621a1ffad0bca905e1bc5a'

mean

mean(<value1> : number) => number

Bir sütunun değerlerinin ortalamasını alır. AVG ile aynı.

  • mean(sales)

meanIf

meanIf(<value1> : boolean, <value2> : number) => number

Ölçütlere göre bir sütunun değerlerinin ortalamasını alır. avgIf ile aynı.

  • meanIf(region == 'West', sales)

millisecond

millisecond(<value1> : timestamp, [<value2> : string]) => integer

Bir tarihin milisaniye değerini alır. İsteğe bağlı bir saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • millisecond(toTimestamp('2009-07-30 12:58:59.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> 871

milliseconds

milliseconds(<value1> : integer) => long

Milisaniye sayısı için milisaniye cinsinden süre.

  • milliseconds(2) -> 2L

min

min(<value1> : any) => any

Bir sütunun en düşük değerini alır.

  • min(sales)

minIf

minIf(<value1> : boolean, <value2> : any) => any

Ölçütlere göre bir sütunun en düşük değerini alır.

  • minIf(region == 'West', sales)

minus

minus(<value1> : any, <value2> : any) => any

Sayıları çıkarır. Bir tarihten gün sayısını çıkarın. Bir zaman damgasından süreyi çıkarın. Milisaniye cinsinden fark elde etmek için iki zaman damgası çıkarın. - işleciyle aynı.

  • minus(20, 10) -> 10
  • 20 - 10 -> 10
  • minus(toDate('2012-12-15'), 3) -> toDate('2012-12-12')
  • toDate('2012-12-15') - 3 -> toDate('2012-12-12')
  • toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS') + (days(1) + hours(2) - seconds(10)) -> toTimestamp('2019-02-04 07:19:18.871', 'yyyy-MM-dd HH:mm:ss.SSS')
  • toTimestamp('2019-02-03 05:21:34.851', 'yyyy-MM-dd HH:mm:ss.SSS') - toTimestamp('2019-02-03 05:21:36.923', 'yyyy-MM-dd HH:mm:ss.SSS') -> -2072

minute

minute(<value1> : timestamp, [<value2> : string]) => integer

Zaman damgasının dakika değerini alır. İsteğe bağlı bir saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • minute(toTimestamp('2009-07-30 12:58:59')) -> 58
  • minute(toTimestamp('2009-07-30 12:58:59'), 'PST') -> 58

minutes

minutes(<value1> : integer) => long

Dakika sayısı için milisaniye cinsinden süre.

  • minutes(2) -> 120000L

mlookup

mlookup(key, key2, ...) => complex[]

Önbelleğe alınan havuzdaki anahtarlarla eşleşen belirtilen anahtarları kullanarak önbelleğe alınan havuzdaki tüm eşleşen satırları arar.

  • cacheSink#mlookup(movieId)

mod

mod(<value1> : any, <value2> : any) => any

Sayı çifti modulus. % işleciyle aynı.

  • mod(20, 8) -> 4
  • 20 % 8 -> 4

month

month(<value1> : datetime) => integer

Tarih veya zaman damgasının ay değerini alır.

  • month(toDate('2012-8-8')) -> 8

monthsBetween

monthsBetween(<from date/timestamp> : datetime, <to date/timestamp> : datetime, [<roundoff> : boolean], [<time zone> : string]) => double

İki tarih arasındaki ay sayısını alır. Hesaplamayı yuvarlayabilirsiniz. İsteğe bağlı bir saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • monthsBetween(toTimestamp('1997-02-28 10:30:00'), toDate('1996-10-30')) -> 3.94959677

multiply

multiply(<value1> : any, <value2> : any) => any

Sayı çiftini çarpar. * işleciyle aynı.

  • multiply(20, 10) -> 200
  • 20 * 10 -> 200

N

negate

negate(<value1> : number) => number

Bir sayıyı olumsuzlar. Pozitif sayıları negatife ve tersine çevirir.

  • negate(13) -> -13

nextSequence

nextSequence() => long

Sonraki benzersiz diziyi döndürür. Sayı yalnızca bir bölüm içinde ardışıktır ve partitionId ön ekini alır.

  • nextSequence() == 12313112 -> false

normalize

normalize(<String to normalize> : string) => string

Dize değerini aksanlı unicode karakterleri ayırmak için normalleştirir.

  • regexReplace(normalize('bo²s'), `\p{M}`, '') -> 'boys'

not

not(<value1> : boolean) => boolean

Mantıksal olumsuzlama işleci.

  • not(true) -> false
  • not(10 == 20) -> true

notEquals

notEquals(<value1> : any, <value2> : any) => boolean

Karşılaştırma eşittir işleci değildir. != işleciyle aynı.

  • 12 != 24 -> true
  • 'bojjus' != 'bo' + 'jjus' -> false

nTile

nTile([<value1> : integer]) => integer

işlevi, NTile her pencere bölümünün n satırlarını en fazla 1 ile arasında değişen demetlere nböler. Demet değerleri en fazla 1'e göre farklılık gösterir. Bölümdeki satır sayısı demet sayısına eşit olarak bölünmezse, kalan değerler ilk demetle başlayarak demet başına bir tane dağıtılır. NTile işlevi, dörttebirlik, deciles ve diğer yaygın özet istatistiklerinin tertileshesaplanması için kullanışlıdır. İşlev başlatma sırasında iki değişken hesaplar: Normal demetin boyutuna fazladan bir satır eklenir. Her iki değişken de geçerli bölümün boyutuna bağlıdır. Hesaplama işlemi sırasında işlev geçerli satır numarasını, geçerli demet numarasını ve demetin değişeceği satır numarasını (bucketThreshold) izler. Geçerli satır sayısı demet eşiğine ulaştığında, demet değeri bir artar ve eşik demet boyutuna (geçerli demet doldurulursa bir ek değer) artar.

  • nTile()
  • nTile(numOfBuckets)

null

null() => null

NULL değeri döndürür. 'null' adlı bir sütun varsa işlevini syntax(null()) kullanın. Kullanan herhangi bir işlem NULL ile sonuçlanır.

  • isNull('dumbo' + null) -> true
  • isNull(10 * null) -> true
  • isNull('') -> false
  • isNull(10 + 20) -> false
  • isNull(10/0) -> true

O

or

or(<value1> : boolean, <value2> : boolean) => boolean

Mantıksal VEYA operatörüdür. || ile aynı.

  • or(true, false) -> true
  • true || false -> true

originColumns

originColumns(<streamName> : string) => any

Sütunların oluşturulduğu kaynak akışı için tüm çıkış sütunlarını alır. Başka bir işlev içine alınmalıdır.

  • array(toString(originColumns('source1')))

output

output() => any

Önbellek havuzu sonuçlarının ilk satırını döndürür

  • cacheSink#output()

outputs

output() => any

Önbellek havuzu sonuçlarının çıkış satırı kümesinin tamamını döndürür

  • cacheSink#outputs()

P

partitionId

partitionId() => integer

Giriş satırının içinde olduğu geçerli bölüm kimliğini döndürür.

  • partitionId()

pMod

pMod(<value1> : any, <value2> : any) => any

Pozitif Sayı çifti modulus.

  • pmod(-20, 8) -> 4

power

power(<value1> : number, <value2> : number) => double

Bir sayıyı diğerinin gücüne yükseltir.

  • power(10, 2) -> 100

R

radians

radians(<value1> : number) => double

Dereceleri radyana dönüştürür

  • radians(180) => 3.141592653589793

random

random(<value1> : integral) => long

Bölüm içinde isteğe bağlı bir tohum verilen rastgele bir sayı döndürür. Tohum sabit bir değer olmalıdır ve rastgele değerler üretmek için partitionId ile birlikte kullanılır

  • random(1) == 1 -> false

rank

rank() => integer

Pencerenin sıralama ölçütü yan tümcesinde belirtilen değer grubundaki bir değerin derecesini hesaplar. Sonuç, bölümün sırasına göre geçerli satırdan önceki veya buna eşit olan satır sayısının bir artı değeridir. Değerler, dizide boşluklar oluşturur. Sıralama, veriler sıralanmadığında bile çalışır ve değerlerde değişiklik arar.

  • rank()

reassociate

reassociate(<value1> : map, <value2> : binaryFunction) => map

Anahtarları yeni değerlerle ilişkilendirerek haritayı dönüştürür. Öğeyi #key ve geçerli değeri #value olarak adresleyebileceğiniz bir eşleme işlevi alır.

  • reassociate(['fruit' -> 'apple', 'vegetable' -> 'tomato'], substring(#key, 1, 1) + substring(#value, 1, 1)) => ['fruit' -> 'fa', 'vegetable' -> 'vt']

reduce

reduce(<value1> : array, <value2> : any, <value3> : binaryfunction, <value4> : unaryfunction) => any

Dizideki öğeleri biriktirir. Reduce, ilk ifade işlevinde #acc ve #item olarak bir akümülatöre ve bir öğeye başvuru bekler ve sonuçta elde edilen değerin ikinci ifade işlevinde #result olarak kullanılmasını bekler.

  • toString(reduce(['1', '2', '3', '4'], '0', #acc + #item, #result)) -> '01234'

regexExtract

regexExtract(<string> : string, <regex to find> : string, [<match group 1-based index> : integral]) => string

Belirli bir regex deseni için eşleşen bir alt dizeyi ayıklayın. Son parametre eşleşme grubunu tanımlar ve atlanırsa varsayılan olarak 1 olarak ayarlanır. Bir dizeyi kaçış olmadan eşleştirmek için (geri tırnak) kullanın <regex>. Dizin 0 tüm eşleşmeleri döndürür. Eşleşme grupları olmadan dizin 1 ve üzeri herhangi bir sonuç döndürmez.

  • regexExtract('Cost is between 600 and 800 dollars', '(\\d+) and (\\d+)', 2) -> '800'
  • regexExtract('Cost is between 600 and 800 dollars', `(\d+) and (\d+)`, 2) -> '800'

regexMatch

regexMatch(<string> : string, <regex to match> : string) => boolean

Dizenin verilen regex deseni ile eşleşip eşleşmediğini denetler. Bir dizeyi kaçış olmadan eşleştirmek için (geri tırnak) kullanın <regex>.

  • regexMatch('200.50', '(\\d+).(\\d+)') -> true
  • regexMatch('200.50', `(\d+).(\d+)`) -> true

regexReplace

regexReplace(<string> : string, <regex to find> : string, <substring to replace> : string) => string

Bir regex deseninin tüm oluşumlarını verilen dizedeki başka bir alt dizeyle değiştirin. Bir dizeyi kaçış yapmadan eşleştirmek için Kullanın <regex>(geri tırnak).

  • regexReplace('100 and 200', '(\\d+)', 'bojjus') -> 'bojjus and bojjus'
  • regexReplace('100 and 200', `(\d+)`, 'gunchus') -> 'gunchus and gunchus'

regexSplit

regexSplit(<string to split> : string, <regex expression> : string) => array

Bir dizeyi regex'e göre sınırlayıcıya göre böler ve bir dize dizisi döndürür.

  • regexSplit('bojjusAgunchusBdumbo', `[CAB]`) -> ['bojjus', 'gunchus', 'dumbo']
  • regexSplit('bojjusAgunchusBdumboC', `[CAB]`) -> ['bojjus', 'gunchus', 'dumbo', '']
  • (regexSplit('bojjusAgunchusBdumboC', `[CAB]`)[1]) -> 'bojjus'
  • isNull(regexSplit('bojjusAgunchusBdumboC', `[CAB]`)[20]) -> true

replace

replace(<string> : string, <substring to find> : string, [<substring to replace> : string]) => string

Bir alt dizenin tüm oluşumlarını verilen dizedeki başka bir alt dizeyle değiştirin. Son parametre atlanırsa, varsayılan olarak boş dize olur.

  • replace('doggie dog', 'dog', 'cat') -> 'catgie cat'
  • replace('doggie dog', 'dog', '') -> 'gie '
  • replace('doggie dog', 'dog') -> 'gie '

reverse

reverse(<value1> : string) => string

Dizeyi tersine çevirir.

  • reverse('gunchus') -> 'suhcnug'

right(<string to subset> : string, <number of characters> : integral) => string

Sağdan karakter sayısına sahip bir alt dize ayıklar. SUBSTRING(str, LENGTH(str) - n, n ile aynıdır.

  • right('bojjus', 2) -> 'us'
  • right('bojjus', 20) -> 'bojjus'

rlike

rlike(<string> : string, <pattern match> : string) => boolean

Dizenin verilen regex deseni ile eşleşip eşleşmediğini denetler.

  • rlike('200.50', `(\d+).(\d+)`) -> true
  • rlike('bogus', `M[0-9]+.*`) -> false

round

round(<number> : number, [<scale to round> : number], [<rounding option> : integral]) => double

İsteğe bağlı ölçek ve isteğe bağlı yuvarlama modu verilen bir sayıyı yuvarlar. Ölçek atlanırsa varsayılan olarak 0 olur. Mod atlanırsa varsayılan olarak ROUND_HALF_UP(5) olarak ayarlanır. Yuvarlama değerleri şunlardır:

  1. ROUND_UP - Sıfırdan uzağa yuvarlama modu.
  2. ROUND_DOWN - Yuvarlama modu sıfıra doğru yuvarlar.
  3. ROUND_CEILING - Pozitif sonsuzluğa doğru yuvarlama modu. [Giriş pozitifse ROUND_UP aynıdır. Negatifse, ROUND_DOWN gibi davranır. Ex = -1.1, ROUND_CEILING ile -1.0, ROUND_UP ile -2 olacaktır]
  4. ROUND_FLOOR - Negatif sonsuzluğa doğru yuvarlama modu. [Giriş pozitifse ROUND_DOWN aynıdır. Negatifse, ROUND_UP] olarak davranır
  5. ROUND_HALF_UP - Her iki komşu da eşit olmadığı sürece "en yakın komşuya" doğru yuvarlama modu, bu durumda ROUND_UP. [Veri akışı için en yaygın + varsayılan].
  6. ROUND_HALF_DOWN - Her iki komşu da eşit olmadığı sürece "en yakın komşuya" doğru yuvarlama modu, bu durumda ROUND_DOWN.
  7. ROUND_HALF_EVEN - Her iki komşu da eşit olmadığı sürece "en yakın komşuya" doğru yuvarlama modu, bu durumda çift komşuya doğru yuvarlar.
  8. ROUND_UNNECESSARY - Yuvarlama modu, yuvarlama işleminin tam sonucu olduğunu, dolayısıyla yuvarlama gerekli olmadığını onaylar.
  • round(100.123) -> 100.0
  • round(2.5, 0) -> 3.0
  • round(5.3999999999999995, 2, 7) -> 5.40

rowNumber

rowNumber() => integer

1 ile başlayan bir penceredeki satırlar için sıralı satır numaralandırması atar.

  • rowNumber()

rpad

rpad(<string to pad> : string, <final padded length> : integral, <padding> : string) => string

Sağlanan doldurmanın dizesini belirli bir uzunlukta olana kadar sağ tuş takımına ekler. Dize uzunluğuna eşit veya ondan büyükse, uzunluğa kırpılır.

  • rpad('dumbo', 10, '-') -> 'dumbo-----'
  • rpad('dumbo', 4, '-') -> 'dumb'
  • rpad('dumbo', 8, '<>') -> 'dumbo<><'

rtrim

rtrim(<string to trim> : string, [<trim characters> : string]) => string

Sağ, sondaki karakter dizesini kırpıyor. İkinci parametre belirtilmemişse, boşluğu kırpar. Aksi halde, ikinci parametrede belirtilen herhangi bir karakteri kırpıyor.

  • rtrim(' dumbo ') -> ' dumbo'
  • rtrim('!--!du!mbo!', '-!') -> '!--!du!mbo'

S

second

second(<value1> : timestamp, [<value2> : string]) => integer

Bir tarihin ikinci değerini alır. İsteğe bağlı bir saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • second(toTimestamp('2009-07-30 12:58:59')) -> 59

seconds

seconds(<value1> : integer) => long

Saniye sayısı için milisaniye cinsinden süre.

  • seconds(2) -> 2000L

setBitSet

setBitSet (<value1>: array, <value2>:array) => array

Bu bit kümesindeki bit konumlarını ayarlar

  • setBitSet(toBitSet([10, 32]), [98]) => [4294968320L, 17179869184L]

sha1

sha1(<value1> : any, ...) => string

Değişen ilkel veri türlerinden oluşan sütun kümesinin SHA-1 özetini hesaplar ve 40 karakterlik onaltılık bir dize döndürür. Bir satır için parmak izi hesaplamak için kullanılabilir.

  • sha1(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> '46d3b478e8ec4e1f3b453ac3d8e59d5854e282bb'

sha2

sha2(<value1> : integer, <value2> : any, ...) => string

Bit uzunluğu verilen ve yalnızca 0(256), 224, 256, 384, 512 değerlerinden oluşan değişen temel veri türlerinden oluşan sütun kümesinin SHA-2 özetini hesaplar. Bir satır için parmak izi hesaplamak için kullanılabilir.

  • sha2(256, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4')) -> 'afe8a553b1761c67d76f8c31ceef7f71b66a1ee6f4e6d3b5478bf68b47d06bd3'

sin

sin(<value1> : number) => double

Sinüs değerini hesaplar.

  • sin(2) -> 0.9092974268256817

sinh

sinh(<value1> : number) => double

Hiperbolik sinüs değerini hesaplar.

  • sinh(0) -> 0.0

size

size(<value1> : any) => integer

Dizi veya eşleme türünün boyutunu bulur

  • size(['element1', 'element2']) -> 2
  • size([1,2,3]) -> 3

skewness

skewness(<value1> : number) => double

Bir sütunun çarpıklığını alır.

  • skewness(sales)

skewnessIf

skewnessIf(<value1> : boolean, <value2> : number) => double

Ölçütlere göre bir sütunun çarpıklığını alır.

  • skewnessIf(region == 'West', sales)

slice

slice(<array to slice> : array, <from 1-based index> : integral, [<number of items> : integral]) => array

Bir konumdan dizinin alt kümesini ayıklar. Konum 1 tabanlıdır. Uzunluk atlanırsa, dizenin sonuna varsayılan olarak eklenir.

  • slice([10, 20, 30, 40], 1, 2) -> [10, 20]
  • slice([10, 20, 30, 40], 2) -> [20, 30, 40]
  • slice([10, 20, 30, 40], 2)[1] -> 20
  • isNull(slice([10, 20, 30, 40], 2)[0]) -> true
  • isNull(slice([10, 20, 30, 40], 2)[20]) -> true
  • slice(['a', 'b', 'c', 'd'], 8) -> []

sort

sort(<value1> : array, <value2> : binaryfunction) => array

Sağlanan koşul işlevini kullanarak diziyi sıralar. Sort, ifade işlevinde #item1 ve #item2 olarak birbirini izleyen iki öğeye başvuru bekler.

  • sort([4, 8, 2, 3], compare(#item1, #item2)) -> [2, 3, 4, 8]
  • sort(['a3', 'b2', 'c1'], iif(right(#item1, 1) >= right(#item2, 1), 1, -1)) -> ['c1', 'b2', 'a3']

soundex

soundex(<value1> : string) => string

Dizenin soundex kodunu alır.

  • soundex('genius') -> 'G520'

split

split(<string to split> : string, <split characters> : string) => array

Bir dizeyi sınırlayıcıya göre böler ve bir dize dizisi döndürür.

  • split('bojjus,guchus,dumbo', ',') -> ['bojjus', 'guchus', 'dumbo']
  • split('bojjus,guchus,dumbo', '|') -> ['bojjus,guchus,dumbo']
  • split('bojjus, guchus, dumbo', ', ') -> ['bojjus', 'guchus', 'dumbo']
  • split('bojjus, guchus, dumbo', ', ')[1] -> 'bojjus'
  • isNull(split('bojjus, guchus, dumbo', ', ')[0]) -> true
  • isNull(split('bojjus, guchus, dumbo', ', ')[20]) -> true
  • split('bojjusguchusdumbo', ',') -> ['bojjusguchusdumbo']

sqrt

sqrt(<value1> : number) => double

Bir sayının karekökünü hesaplar.

  • sqrt(9) -> 3

startsWith

startsWith(<string> : string, <substring to check> : string) => boolean

Dizenin sağlanan dizeyle başlayıp başlamadığını denetler.

  • startsWith('dumbo', 'du') -> true

stddev

stddev(<value1> : number) => double

Bir sütunun standart sapması alır.

  • stdDev(sales)

stddevIf

stddevIf(<value1> : boolean, <value2> : number) => double

Ölçütlere göre bir sütunun standart sapması elde eder.

  • stddevIf(region == 'West', sales)

stddevPopulation

stddevPopulation(<value1> : number) => double

Bir sütunun popülasyon standart sapması alır.

  • stddevPopulation(sales)

stddevPopulationIf

stddevPopulationIf(<value1> : boolean, <value2> : number) => double

Ölçütlere göre bir sütunun popülasyon standart sapması elde eder.

  • stddevPopulationIf(region == 'West', sales)

stddevSample

stddevSample(<value1> : number) => double

Bir sütunun örnek standart sapması alır.

  • stddevSample(sales)

stddevSampleIf

stddevSampleIf(<value1> : boolean, <value2> : number) => double

Ölçütlere göre bir sütunun örnek standart sapması elde eder.

  • stddevSampleIf(region == 'West', sales)

subDays

subDays(<date/timestamp> : datetime, <days to subtract> : integral) => datetime

Bir tarih veya zaman damgasından gün çıkarma. Tarih için - işleciyle aynıdır.

  • subDays(toDate('2016-08-08'), 1) -> toDate('2016-08-07')

subMonths

subMonths(<date/timestamp> : datetime, <months to subtract> : integral) => datetime

Bir tarih veya zaman damgasından ayları çıkarın.

  • subMonths(toDate('2016-09-30'), 1) -> toDate('2016-08-31')

substring

substring(<string to subset> : string, <from 1-based index> : integral, [<number of characters> : integral]) => string

Belirli bir uzunluktaki alt dizeyi bir konumdan ayıklar. Konum 1 tabanlıdır. Uzunluk atlanırsa, dizenin sonuna varsayılan olarak eklenir.

  • substring('Cat in the hat', 5, 2) -> 'in'
  • substring('Cat in the hat', 5, 100) -> 'in the hat'
  • substring('Cat in the hat', 5) -> 'in the hat'
  • substring('Cat in the hat', 100, 100) -> ''

substringIndex

substringIndex(<dizeden alt sınırlayıcıya>><alt dizeIndex( : string, : string, <sınırlayıcı oluşma sayısı> : integral]) = dize>

Sınırlayıcının oluşumlarından önce count alt dizeyi ayıklar. Pozitifse count , son sınırlayıcının solundaki her şey (soldan sayma) döndürülür. Negatifse count , son sınırlayıcının sağındaki her şey (sağdan sayma) döndürülür.

  • substringIndex('111-222-333', '-', 1) -> '111'
  • substringIndex('111-222-333', '-', 2) -> '111-222'
  • substringIndex('111-222-333', '-', -1) -> '333'
  • substringIndex('111-222-333', '-', -2) -> '222-333'

sum

sum(<value1> : number) => number

Sayısal sütunun toplam toplamını alır.

  • sum(col)

sumDistinct

sumDistinct(<value1> : number) => number

Sayısal bir sütunun ayrı değerlerinin toplam toplamını alır.

  • sumDistinct(col)

sumDistinctIf

sumDistinctIf(<value1> : boolean, <value2> : number) => number

Ölçütlere göre sayısal bir sütunun toplam toplamını alır. Koşul herhangi bir sütunu temel alabilir.

  • sumDistinctIf(state == 'CA' && commission < 10000, sales)
  • sumDistinctIf(true, sales)

sumIf

sumIf(<value1> : boolean, <value2> : number) => number

Ölçütlere göre sayısal bir sütunun toplam toplamını alır. Koşul herhangi bir sütunu temel alabilir.

  • sumIf(state == 'CA' && commission < 10000, sales)
  • sumIf(true, sales)

T

tan

tan(<value1> : number) => double

Tanjant değerini hesaplar.

  • tan(0) -> 0.0

tanh

tanh(<value1> : number) => double

Hiperbolik tanjant değerini hesaplar.

  • tanh(0) -> 0.0

toBase64

toBase64(<value1> : string, <encoding type> : string]) => string

Verilen dizeyi base64'te kodlar. İsteğe bağlı olarak kodlama türünü geçirebilirsiniz

  • toBase64('bojjus') -> 'Ym9qanVz'
  • toBase64('± 25000, € 5.000,- |', 'Windows-1252') -> 'sSAyNTAwMCwggCA1LjAwMCwtIHw='

toBinary

toBinary(<value1> : any) => binary

Herhangi bir sayısal/tarih/zaman damgası/dizeyi ikili gösterime dönüştürür.

  • toBinary(3) -> [0x11]

toBoolean

toBoolean(<value1> : string) => boolean

('t', 'true', 'y', 'yes', '1') değerini true ve ('f', 'false', 'n', 'no', '0') değerlerini false ve NULL değerlerine dönüştürür.

  • toBoolean('true') -> true
  • toBoolean('n') -> false
  • isNull(toBoolean('truthy')) -> true

toByte

toByte(<value> : any, [<format> : string], [<locale> : string]) => byte

Herhangi bir sayısal veya dizeyi bayt değerine dönüştürür. Dönüştürme için isteğe bağlı bir Java ondalık biçimi kullanılabilir.

  • toByte(123)
  • 123
  • toByte(0xFF)
  • -1
  • toByte('123')
  • 123

toDate

toDate(<string> : any, [<date format> : string]) => date

İsteğe bağlı bir giriş tarihi biçimi kullanarak giriş tarihi dizesini tarihe dönüştürür. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. Giriş tarihi biçimi atlanırsa, varsayılan biçim yyyy-[M]M-[d]d olur. Kabul edilen biçimler: :[ yyyy, yyyy-[M]M, yyyy-[M]M-[d]d, yyyy-[M]M-[d]dT* ].

  • toDate('2012-8-18') -> toDate('2012-08-18')
  • toDate('12/18/2012', 'MM/dd/yyyy') -> toDate('2012-12-18')

toDecimal

toDecimal(<value> : any, [<precision> : integral], [<scale> : integral], [<format> : string], [<locale> : string]) => decimal(10,0)

Herhangi bir sayısal veya dizeyi ondalık değere dönüştürür. Duyarlık ve ölçek belirtilmezse varsayılan olarak (10,2) olur. Dönüştürme için isteğe bağlı bir Java ondalık biçimi kullanılabilir. EN-US, de, zh-CN gibi BCP47 dili biçiminde isteğe bağlı bir yerel ayar biçimi.

  • toDecimal(123.45) -> 123.45
  • toDecimal('123.45', 8, 4) -> 123.4500
  • toDecimal('$123.45', 8, 4,'$###.00') -> 123.4500
  • toDecimal('Ç123,45', 10, 2, 'Ç###,##', 'de') -> 123.45

toDouble

toDouble(<value> : any, [<format> : string], [<locale> : string]) => double

Herhangi bir sayısal veya dizeyi çift değere dönüştürür. Dönüştürme için isteğe bağlı bir Java ondalık biçimi kullanılabilir. EN-US, de, zh-CN gibi BCP47 dili biçiminde isteğe bağlı bir yerel ayar biçimi.

  • toDouble(123.45) -> 123.45
  • toDouble('123.45') -> 123.45
  • toDouble('$123.45', '$###.00') -> 123.45
  • toDouble('Ç123,45', 'Ç###,##', 'de') -> 123.45

toFloat

toFloat(<value> : any, [<format> : string], [<locale> : string]) => float

Herhangi bir sayısal veya dizeyi float değerine dönüştürür. Dönüştürme için isteğe bağlı bir Java ondalık biçimi kullanılabilir. Herhangi bir çifti keser.

  • toFloat(123.45) -> 123.45f
  • toFloat('123.45') -> 123.45f
  • toFloat('$123.45', '$###.00') -> 123.45f

toInteger

toInteger(<value> : any, [<format> : string], [<locale> : string]) => integer

Herhangi bir sayısal veya dizeyi tamsayı değerine dönüştürür. Dönüştürme için isteğe bağlı bir Java ondalık biçimi kullanılabilir. Uzun, kayan, çift kesen.

  • toInteger(123) -> 123
  • toInteger('123') -> 123
  • toInteger('$123', '$###') -> 123

toLong

toLong(<value> : any, [<format> : string], [<locale> : string]) => long

Herhangi bir sayısal veya dizeyi uzun bir değere dönüştürür. Dönüştürme için isteğe bağlı bir Java ondalık biçimi kullanılabilir. Herhangi bir şamandırayı ikiye katlar.

  • toLong(123) -> 123
  • toLong('123') -> 123
  • toLong('$123', '$###') -> 123

topN

topN(<column/expression> : any, <count> : long, <n> : integer) => array

Bu sütun için count bağımsız değişkenine göre en yüksek N değerlerini alır.

  • topN(custId, count, 5)
  • topN(productId, num_sales, 10)

toShort

toShort(<value> : any, [<format> : string], [<locale> : string]) => short

Herhangi bir sayısal veya dizeyi kısa bir değere dönüştürür. Dönüştürme için isteğe bağlı bir Java ondalık biçimi kullanılabilir. Herhangi bir tamsayıyı, uzun, kayan, çifti kesebilir.

  • toShort(123) -> 123
  • toShort('123') -> 123
  • toShort('$123', '$###') -> 123

toString

toString(<value> : any, [<number format/date format> : string], [<date locale> : string]) => string

İlkel veri türünü dizeye dönüştürür. Sayılar ve tarih için bir biçim belirtilebilir. Belirtilmemişse, sistem varsayılanı seçilir. Sayılar için Java ondalık biçimi kullanılır. Tüm olası tarih biçimleri için Java SimpleDateFormat'a bakın; varsayılan biçim yyyy-AA-gg şeklindedir. Tarih veya zaman damgası için isteğe bağlı olarak bir yerel ayar belirtilebilir.

  • toString(10) -> '10'
  • toString('engineer') -> 'engineer'
  • toString(123456.789, '##,###.##') -> '123,456.79'
  • toString(123.78, '000000.000') -> '000123.780'
  • toString(12345, '##0.#####E0') -> '12.345E3'
  • toString(toDate('2018-12-31')) -> '2018-12-31'
  • isNull(toString(toDate('2018-12-31', 'MM/dd/yy'))) -> true
  • toString(4 == 20) -> 'false'
  • toString(toDate('12/31/18', 'MM/dd/yy', 'es-ES'), 'MM/dd/yy', 'de-DE')

toTimestamp

toTimestamp(<string> : any, [<timestamp format> : string], [<time zone> : string]) => timestamp

İsteğe bağlı bir zaman damgası biçimi verilen bir dizeyi zaman damgasına dönüştürür. Zaman damgası atlanırsa varsayılan desen yyyy-[M]M-[d]d hh:mm:ss[.f...] kullanılır. İsteğe bağlı bir saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Zaman damgası, 999 değeriyle milisaniyeye kadar doğruluğu destekler. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • toTimestamp('2016-12-31 00:12:00') -> toTimestamp('2016-12-31 00:12:00')
  • toTimestamp('2016-12-31T00:12:00', 'yyyy-MM-dd\'T\'HH:mm:ss', 'PST') -> toTimestamp('2016-12-31 00:12:00')
  • toTimestamp('12/31/2016T00:12:00', 'MM/dd/yyyy\'T\'HH:mm:ss') -> toTimestamp('2016-12-31 00:12:00')
  • millisecond(toTimestamp('2019-02-03 05:19:28.871', 'yyyy-MM-dd HH:mm:ss.SSS')) -> 871

toUTC

toUTC(<value1> : timestamp, [<value2> : string]) => timestamp

Zaman damgasını UTC'ye dönüştürür. İsteğe bağlı bir saat dilimini 'GMT', 'PST', 'UTC', 'America/Cayman' biçiminde geçirebilirsiniz. Varsayılan olarak geçerli saat dilimidir. Kullanılabilir biçimler için Java sınıfına SimpleDateFormat bakın. https://docs.oracle.com/javase/8/docs/api/java/text/SimpleDateFormat.html.

  • toUTC(currentTimestamp()) == toTimestamp('2050-12-12 19:18:12') -> false
  • toUTC(currentTimestamp(), 'Asia/Seoul') != toTimestamp('2050-12-12 19:18:12') -> true

translate

translate(<string to translate> : string, <lookup characters> : string, <replace characters> : string) => string

Bir karakter kümesini dizedeki başka bir karakter kümesiyle değiştirin. Karakterlerin 1 ile 1 arası değişimi vardır.

  • translate('(bojjus)', '()', '[]') -> '[bojjus]'
  • translate('(gunchus)', '()', '[') -> '[gunchus'

trim

trim(<string to trim> : string, [<trim characters> : string]) => string

Baştaki ve sondaki karakterlerden oluşan bir dizeyi kırpar. İkinci parametre belirtilmemişse, boşluğu kırpar. Aksi halde, ikinci parametrede belirtilen herhangi bir karakteri kırpıyor.

  • trim(' dumbo ') -> 'dumbo'
  • trim('!--!du!mbo!', '-!') -> 'dumbo'

true

true() => boolean

Her zaman doğru bir değer döndürür. 'true' adlı bir sütun varsa işlevini syntax(true()) kullanın.

  • (10 + 20 == 30) -> true
  • (10 + 20 == 30) -> true()

typeMatch

typeMatch(<type> : string, <base type> : string) => boolean

Sütunun türüyle eşleşir. Yalnızca desen ifadelerinde kullanılabilir.sayı kısa, tamsayı, uzun, çift, kayan veya ondalık ile eşleşir, tamsayı kısa, tamsayı, uzun, kesirli eşleşmeler çift, kayan, ondalık ve tarih saat tarih veya zaman damgası türüyle eşleşir.

  • typeMatch(type, 'number')
  • typeMatch('date', 'datetime')

U

unescape

unescape(<string_to_escape> : string, <format> : string) => string

Bir dizeyi biçime göre kaldırıyor. Kabul edilebilir biçim için değişmez değerler :'json', 'xml', 'ecmascript', 'html', 'java'.

  • unescape('{\\\\\"value\\\\\": 10}', 'json')
  • '{\\\"value\\\": 10}'

unfold

unfold (<value1>: array) => any

Bir diziyi bir satır kümesine açar ve her satırdaki kalan sütunların değerlerini yineler.

  • unfold(addresses) => any
  • unfold( @(name = salesPerson, sales = salesAmount) ) => any

unhex

unhex(<value1>: string) => binary

bir ikili değeri dize gösteriminden kaldırır. Bu, dizeden ikili gösterime dönüştürmek için sha2, md5 ile kullanılabilir

  • unhex('1fadbe') -> toBinary([toByte(0x1f), toByte(0xad), toByte(0xbe)])
  • unhex(md5(5, 'gunchus', 8.2, 'bojjus', true, toDate('2010-4-4'))) -> toBinary([toByte(0x4c),toByte(0xe8),toByte(0xa8),toByte(0x80),toByte(0xbd),toByte(0x62),toByte(0x1a),toByte(0x1f),toByte(0xfa),toByte(0xd0),toByte(0xbc),toByte(0xa9),toByte(0x05),toByte(0xe1),toByte(0xbc),toByte(0x5a)])

union

union(<value1>: array, <value2> : array) => array

2 diziden ayrı öğelerden oluşan bir birleşim kümesi döndürür.

  • union([10, 20, 30], [20, 40]) => [10, 20, 30, 40]

upper

upper(<value1> : string) => string

Bir dizeyi büyük harfle ifade eder.

  • upper('bojjus') -> 'BOJJUS'

uuid

uuid() => string

Oluşturulan UUID değerini döndürür.

  • uuid()

V

variance

variance(<value1> : number) => double

Bir sütunun varyansını alır.

  • variance(sales)

varianceIf

varianceIf(<value1> : boolean, <value2> : number) => double

Ölçütlere göre bir sütunun varyansını alır.

  • varianceIf(region == 'West', sales)

variancePopulation

variancePopulation(<value1> : number) => double

Bir sütunun popülasyon varyansını alır.

  • variancePopulation(sales)

variancePopulationIf

variancePopulationIf(<value1> : boolean, <value2> : number) => double

Ölçütlere göre bir sütunun popülasyon varyansını alır.

  • variancePopulationIf(region == 'West', sales)

varianceSample

varianceSample(<value1> : number) => double

Bir sütunun sapmasız varyansını alır.

  • varianceSample(sales)

varianceSampleIf

varianceSampleIf(<value1> : boolean, <value2> : number) => double

Ölçütlere göre sütunun sapmasız varyansını alır.

  • varianceSampleIf(region == 'West', sales)

Ça

weekOfYear

weekOfYear(<value1> : datetime) => integer

Bir tarih verilen yılın haftasını alır.

  • weekOfYear(toDate('2008-02-20')) -> 8

weeks

weeks(<value1> : integer) => long

Hafta sayısı için milisaniye cinsinden süre.

  • weeks(2) -> 1209600000L

X

xor

xor(<value1> : boolean, <value2> : boolean) => boolean

Mantıksal XOR işleci. ^ işleciyle aynı.

  • xor(true, false) -> true
  • xor(true, true) -> false
  • true ^ false -> true

Y

year

year(<value1> : datetime) => integer

Tarihin yıl değerini alır.

  • year(toDate('2012-8-8')) -> 2012

İlgili içerik