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

UYGULANANLAR: Azure Data Factory Azure Synapse Analytics

Tip

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 işlem hatlarında hem de Azure Synapse Analytics işlem hatlarında kullanılabilir. Bu makale, eşleme veri akışları için geçerlidir. Dönüştürmeler hakkında yeniyseniz , Eşleme veri akışlarını kullanarak verileri dönüştürme başlıklı giriş makalesine bakın.

Bu makalede, 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 bakın:

Tüm işlevlerin alfabetik listesi

Aşağıdaki alfabetik liste, eşleme veri akışlarında kullanılabilen tüm işlevleri içerir.

A

`abs`

abs(<value1> : number) => number

Bir sayının mutlak değerini döndürür.

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. Birçok güne tarih ekler. Zaman damgasına süre ekler. Benzer türde bir diziyi diğerine ekler. İşleçle + 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

Tarih veya saat damgasına gün ekler. Tarihler için + operatörü ile aynıdır.

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

`addMonths`

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

Tarih veya saat damgasına aylar ekler. İ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şlecini kullanır. &&ile aynıdır.

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.

Examples

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. Hiçbir öğe belirtilmezse, dizenin dize türüyle eşlemini varsayılan olarak belirler. 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. Dizin sınırı aşıldığında null bir değerle sonuçlanır. Anahtar verildiğinde haritadaki bir değeri bulur. Anahtar bulunamazsa null bir değer 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)

B

`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 datetime değerleri karşılaştırabilirsiniz.

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 And işlecini kullanır. İşleçle & 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şlecini kullanır. İşleçle | aynı.

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şlecini kullanır. | işleciyle aynı

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

`blake2b`

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

Bit uzunluğu verildiğinde değişen ilkel veri türlerinden oluşan bir sütun kümesinin Blake2 özetini hesaplar. Bu değer 8 ile 512 arasında yalnızca 8'in katları olabilir. Bir satır için parmak izi hesaplamak için bunu kullanabilirsiniz.

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

`blake2bBinary`

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

Bit uzunluğu verildiğinde değişen ilkel veri türlerinden oluşan bir sütun kümesinin Blake2 özetini hesaplar. Bu değer 8 ile 512 arasında yalnızca 8'in katları olabilir. Bir satır için parmak izi hesaplamak için bunu kullanabilirsiniz.

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 bulur. Birden çok eşleşme varsa, ilk eşleşme döndürülür. Eşleşme yoksa bir NULL değer döndürülür. Döndürülen değer, ? date ve ? string gibi tür dönüştürme eylemlerinden biri tarafından dönüştürülmelidir. Tasarım zamanında bilinen sütun adlarına, adlarıyla dayanarak erişin. 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 bir NULL değer döndürülür. Döndürülen değerin, tür dönüştürme işlevlerinden biri olan TO_DATE ve TO_STRING gibi işlevler tarafından dönüştürülmesi gerekir. Tasarım zamanında bilinen sütun adlarına, adlarıyla dayanarak erişin. 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ı bir NULL değerdir. Döndürülen değer, bir tür dönüştürme işlevi gerektirir (örneğin toDate ve toString). Tasarım zamanında bilinen sütun adlarına, adlarıyla dayanarak erişin. 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 bir NULL değer döndürülür. Döndürülen değerin, tür dönüştürme işlevlerinden biri olan TO_DATE ve TO_STRING gibi işlevler tarafından dönüştürülmesi gerekir. Tasarım zamanında bilinen sütun adlarına, adlarıyla dayanarak erişin. 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 argüman, kaynağından geldiği akıştır. Birden çok eşleşme varsa, ilk eşleşme döndürülür. Eşleşme yoksa bir NULL değer döndürülür. Döndürülen değerin, tür dönüştürme işlevlerinden biri olan TO_DATE ve TO_STRING gibi işlevler tarafından dönüştürülmesi gerekir. Tasarım zamanında bilinen sütun adlarına, adlarıyla dayanarak erişin. 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 geri döner. Tasarım zamanında bilinen sütun adları/yolları yalnızca adları veya noktalı notasyon yolları kullanılarak 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 bir NULL değer döndürür. Döndürülen değer, tür dönüştürme işlevlerinden biri (veya TO_DATEgibiTO_STRING) tarafından dönüştürülmelidir. 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 case işlev bir değer veya diğerini uygular. Giriş sayısı eşitse, diğeri son koşul için varsayılan olarak ayarlanır NULL .

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 ile eşdeğerdir (sayı % 256).

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ı toplayabilir ve alternatif yapılara dönüştürebilirsiniz. Öğe sayısı, bu gruptaki satır sayısına eşittir 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ı toplayabilir ve alternatif yapılara dönüştürebilirsiniz. Öğe sayısı, bu gruptaki satır sayısına eşittir 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 Data Factory 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 bir tamsayı, değer1 == değer2 ise 0 ve değer1 > değer2 ise pozitif bir 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. String'ler ile + işleçle 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, verilen koşuldaki true ile değerlendirilirse true döndürür. The contains işlevi, koşul işlevindeki bir öğeye #item referans 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. Bir veya daha fazla isteğe bağlı sütun belirtilirse, NULL değerlerini sayıma dahil etmez.

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



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


Null değerler 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ğerler 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ımda 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 verildiğinde değişen ilkel veri türlerinden oluşan bir sütun kümesinin CRC32 karması hesaplar; bu yalnızca değerlerden 0(256oluşabilir ), 224, 256, 384ve 512. Bir satır için parmak izi hesaplamak için bunu kullanabilirsiniz.

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



cumeDist
cumeDist() => integer


işlevi, cumeDist 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 veya America/Cayman biçiminde geçebilirsiniz. Veri fabrikasının veri merkezinin/bölgesinin yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın.

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, , , GMTPSTveya UTCbiçiminde America/Caymanisteğe bağlı bir saat dilimi geçirebilirsiniz. Varsayılan olarak geçerli saat dilimini kullanır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın. 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 verildiğinde ayın gününü alır.

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



dayOfWeek
dayOfWeek(<value1> : datetime) => integer


Bir tarih verildiğinde haftanın gününü alır. Örneğin, 1 Pazar, 2 Pazartesi, ... Ve 7 cumartesi.

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



dayOfYear
dayOfYear(<value1> : datetime) => integer


Bir tarih verildiğinde 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. Hangi karakter kümesinin kullanılacağını belirtmek için ikinci (isteğe bağlı) bir bağımsız değişken kullanabilirsiniz. Örnek olarak US-ASCII, , ISO-8859-1UTF-8(varsayılan), UTF-16BE, UTF-16LEve UTF-16verilebilir.

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şluklar oluşturmaz. İşlev, denseRank 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. Hangi karakter kümesinin kullanılacağını belirtmek için ikinci (isteğe bağlı) bir bağımsız değişken kullanılabilir. Örnek olarak US-ASCII, , ISO-8859-1UTF-8(varsayılan), UTF-16BE, UTF-16LEve UTF-16verilebilir.

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



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şlecini kullanır. İşleçle == 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


Büyük/küçük harf duyarsız eşitlik karşılaştırma işlecini kullanır. İşleçle <=> aynı.

'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 ve java şeklindedir.


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


Bir dizeden gelen bir ifadeyle sonuçlanır ve bu ifadeyi alfabe dışı bir biçimde yazmakla aynıdır. Parametreleri dize gösterimi olarak geçirmek için bunu kullanabilirsiniz.

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. Bir sütunun adı false ise, syntax(false()) işlevini 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 fonksiyonundaki 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 kabul eder. İç içe yerleştirilmiş haritalar için #item_n (#item_1, #item_2...) gösterimini kullanarak üst haritalara 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. İkinci parametre ignoreNulls atlanırsa Data Factory false kabul eder.

first(sales)
first(sales, false)



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


Bir 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


Belirli base64 ile 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, veya America/Cayman biçiminde geçirebilirsiniz. Varsayılan olarak geçerli saat dilimini kullanır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın.

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şlecini kullanır. İş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


İşleçten büyük veya eşittir karşılaştırmasını kullanır. İşleçle >= aynı.

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



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


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

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ına, adlarıyla dayanarak erişin. Hesaplanan girişler desteklenmez, ancak parametre değiştirmelerini kullanabilirsiniz.

hasColumn('parent')



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


Sağlanan kimliğe sahip varlığın hata olarak işaretlenip işaretlenmediğini kontrol eder.
Examples

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ı veya noktalı notasyon yolları kullanılarak 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 veya America/Cayman biçiminde geçebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın.

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



hours
hours(<value1> : integer) => long


Belirtilen saat sayısının milisaniye cinsinden süresini alır.

hours(2) -> 7200000L


I

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


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

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ş verildiğinde ilk null olmayan öğeyi döndürür. Bu işlev, coalesce işleviyle 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. Bulunamazsa 0 döndürülür.

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



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


İki 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 toBoolean()göre boole değeri olup olmadığını denetler.

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



isByte
isByte(<value1> : string) => boolean


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

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 sınıfına bakın. Giriş tarihi biçimi atlanırsa, varsayılan biçim olur yyyy-[M]M-[d]d. Kabul edilen biçimler şeklindedir :[ 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, toDecimal() kuralları ve verilen isteğe bağlı biçime göre ondalık sayı olup olmadığını denetler.

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



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


Satırın silinip silinmediğini denetler. Birden fazla giriş akışı alan dönüştürmeler için, akışın (1'den başlayan) dizinini geçirebilirsiniz. Akış dizini 1 veya 2 olmalıdır ve varsayılan değer 1'dir.

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


kurallarına göre isteğe bağlı bir biçim verildiğinde dize değerinin toDouble()çift değer olup olmadığını denetler.

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'den başlayan) dizinini geçirebilirsiniz. Akış dizini ya 1 ya da 2 olmalı ve varsayılan değer 1 olmalıdır.

isError()
isError(1)



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


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

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



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


Satırın yoksayılıp yoksayılmaması gerektiğini kontrol eder. Birden fazla giriş akışı alan dönüştürmeler için akışların (1 tabanlı) dizinini geçirebilirsiniz. Akış dizini 1 veya 2 olmalıdır ve varsayılan değer 1'dir.

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üşümler için, akışın dizinini (1'den başlayarak) belirtebilirsiniz. Akış dizini 1 veya 2 olmalıdır ve varsayılan değer 1'dir.

isInsert()
isInsert(1)



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


kurallarına göre isteğe bağlı bir biçim verildiğinde dize değerinin toInteger()tamsayı değeri olup olmadığını denetler.

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



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


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

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ışı kullanan dönüşümler için, akışların 1-bazlı dizinini geçirebilirsiniz. Akış dizini 1 veya 2 olmalıdır ve varsayılan değer 1'dir.

isMatch()
isMatch(1)



isNan
isNan (<value1> : integral) => boolean


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

isNan(10.2) => false



isNull
isNull(<value1> : any) => boolean


Değerin NULL olup olmadığını kontrol eder.

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



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


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

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 zaman damgası olup olmadığını denetler. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına 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 veya America/Cayman biçiminde geçebilirsiniz. 
              timestamp işlevi, değeriyle 999milisaniyeye kadar doğruluğu destekler. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfı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üşümler için akışın (1 tabanlı) indeksini geçirebilirsiniz. Akış dizini 1 veya 2 olmalıdır ve varsayılan değer 1'dir.

isUpdate()
isUpdate(1)



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


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

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 çarpıklığı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 n ilk parametre satırının değerini alır. İkinci parametre, geriye bakacak satır sayısıdır ve varsayılan değerdir 1. Ç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. İkinci parametre ignoreNulls atlanırsa false olduğu varsayılır.

last(sales)
last(sales, false)



lastDayOfMonth
lastDayOfMonth(<value1> : datetime) => date


Bir tarih verildiğinde 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 sonraki n satırlarda değerlendirilen ilk parametrenin değerini alır. İkinci parametre, ileriye bakacak satır sayısıdır ve varsayılan değerdir 1. Ç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


Küçük veya eşittir işleci karşılaştırmasını kullanır. İşleçle <= aynı.

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


Dizinde 1 başlayan ve belirli bir karakter sayısına sahip bir alt dize 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 küçük işlecini kullanır. İş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


Küçük veya eşittir işleci karşılaştırmasını kullanır. İşleçle <= aynı.

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


Kelimenin tam anlamıyla eşleşen bir dize deseni kullanır. Özel durumlar şu özel simgelerdir: _ girişteki herhangi bir karakterle eşleşir (normal ifadelerde olduğu .* gibiposix).
% girişteki sıfır veya daha fazla karakterle eşleşir (normal ifadelerde olduğu .* gibiposix).
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 belirtilmezse, dizenin başından başlar. Bulunamazsa 0 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


Logaritma değerini hesaplar. İsteğe bağlı bir taban veya kullanılıyorsa bir Euler numarası sağlayabilirsiniz.

log(100, 10) -> 2



log10
log10(<value1> : number) => double


10 tabanında logaritma değerini 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


Verilen doldurma ile dize, belirli bir uzunluğa ulaşana kadar sola doldurulur. Dize uzunluğuna eşit veya ondan büyükse, dize 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ırpıyor. Aksi takdirde, ikinci parametrede belirtilen herhangi bir karakteri kırpar.

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. Bu işlev, map ifadesi işlevindeki #item bir öğeye referans 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. Eşleme işlevi, öğeyi #key ve geçerli değeri #value olarak adresleyebileceğiniz bir yapı sağlar.

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 koşullu olarak aynı veya daha küçük uzunlukta başka bir diziyle eşler. Değerler, dahil olmak üzere structTypesherhangi bir veri türünde olabilir. Dizideki öğeyi `#item` ve geçerli dizini `#index` olarak adresleyebileceğiniz bir eşleme işlevi alır. Derin iç içe yerleştirilmiş haritalar için, üst haritalara ''#item_[n] (#item_1, #index_1'') gösterimini kullanarak 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 işlevi, ifade işlevindeki bir öğeye #item olarak bir başvuru ve öğe dizinine #index olarak bir başvuru bekler.

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



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



              1 başlangıcından belirlenen uzunluğa kadar döngü oluşturarak o uzunlukta bir dizi oluşturur. Bir eşleme işlevi alır, burada dizideki dizini #index olarak adresleyebilirsiniz. İç 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 bir 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 bunu kullanabilirsiniz.

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. 
              AVGile aynıdır.

mean(sales)



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


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

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 veya America/Cayman biçiminde geçebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın.

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üreyi alır.

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ır. Süreyi zaman damgasından çıkarır. Milisaniye cinsinden iki zaman damgası arasındaki farkı hesaplar. İşleçle - 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 veya America/Cayman biçiminde geçebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın.

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üreyi alır.

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


İki sayının modunu alır. İşleçle % aynı.

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



month
month(<value1> : datetime) => integer


Tarih veya saat 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 veya America/Cayman biçiminde geçebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın.

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



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


Sayı çiftini çarpar. İşleçle * 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 bölüm kimliği ön ekini alır.

nextSequence() == 12313112 -> false



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


Dize değerini, vurgulanmış Unicode karakterlerini ayırmak için normalleştirir.

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



not
not(<value1> : boolean) => boolean


Mantıksal olumsuzlama işlecini kullanır.

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



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


Karşılaştırma eşittir işlecini kullanmaz. İşleçle != aynı.

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



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



              nTile işlevi, her pencere bölümünün satırlarını n1 ile en fazla n arasında değişen parçalar halinde böler. Demet değerleri, en çok 1değerine 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. işlevi başlatma sırasında iki değişken hesaplar. Normal bir 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ştiği satır numarasını (bucketThreshold) izler. Geçerli satır numarası küme eşiğine ulaştığında, küme değeri bir artar. Eşik, kova boyutuna göre artar (geçerli kova doldurulmuşsa bir tane fazladan artar).

nTile()
nTile(numOfBuckets)



null
null() => null


Bir NULL değer döndürür. Bir sütunun adı null ise, syntax(null()) işlevini kullanın. Null kullanan herhangi bir işlem bir NULL değerle sonuç verir.

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 OR işlecini kullanır. 
              ||ile aynıdır.

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


Bir çift sayının pozitif modüllerini verir.

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 radyanlara dönüştürür.

radians(180) => 3.141592653589793



random
random(<value1> : integral) => double


Bölüm içinde bir tohum verildiğinde rastgele bir sayı döndürür. Çekirdek sabit bir değer olmalıdır ve bir aralıkta (0.0-1.0 ) rastgele değerler üretmek için bölüm kimliğiyle 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. İşlev, rank 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. Eşleme işlevi, öğeyi #key ve geçerli değeri #value olarak adresleyebileceğiniz bir yapı sağlar.

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. İşlev, reduce ve olarak #acc #itemilk ifade işlevinde bir akümülatöre ve bir öğeye başvuru bekler. elde edilen değerin #result ikinci ifade işlevinde 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 dize ayıklar. Son parametre, eşleşme grubunu tanımlar ve atlanırsa varsayılan olarak 1 kullanılır. Kaçış olmadan bir dizeyi eşleştirmek için kullanın <regex> . Dizin 0 tüm eşleşmeleri döndürür. Eşleşme grupları olmadan dizin 1 ve üzeri hiç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. Kaçış olmadan bir dizeyi eşleştirmek için 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ı belirli dizedeki başka bir alt dizeyle değiştirir. Kaçış olmadan bir dizeyi eşleştirmek için kullanın <regex> .

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ı belirli bir dizedeki başka bir alt dizeyle değiştirir. Son parametre atlanırsa, varsayılan olarak boş bir dizeye ayarlanır.

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
right(<string to subset> : string, <number of characters> : integral) => string


Sağdan birkaç karakter içeren 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 verildiğinde sayıyı yuvarlar. Ölçek atlanırsa, varsayılan olarak 0olur. Mod çıkarılırsa varsayılan olarak ROUND_HALF_UP(5) değerini alır. Yuvarlama değerleri şunlardır:


              ROUND_UP: Sıfırdan uzağa yuvarlama modu.


              ROUND_DOWN: Sıfıra doğru yuvarlama modu.


              ROUND_CEILING: Pozitif sonsuzluk yönüne yuvarlama modu. (Giriş pozitif olduğunda ROUND_UP ile aynıdır. Negatif olduğunda, ROUND_DOWN gibi davranır. Örneğin, -1.1 ROUND_CEILING ile -1.0 ve ROUND_UP ile -2 olur.)


              ROUND_FLOOR: Negatif sonsuzluğa doğru yuvarlama modu. (Girişin pozitif olmasıyla ROUND_DOWN aynıdır. Negatifse, olarak davranır ROUND_UP.)


              ROUND_HALF_UP: Her iki komşu da eşit uzaklıkta olmadığı sürece "en yakın komşuya" doğru yuvarlama modu, bu durumda ROUND_UP gibi davranır. (Veri akışı için en yaygın + varsayılan.)


              ROUND_HALF_DOWN: Hangi komşu daha yakınsa ona doğru yuvarlama modu, ancak her iki komşu da eşit uzaklıkta olduğunda ROUND_DOWN kullanılır.


              ROUND_HALF_EVEN: Her iki komşu eşit mesafede olmadığı sürece "en yakın komşuya" doğru yuvarlama modu uygulanır; eşit mesafede olduklarında çift olan komşuya doğru yuvarlanır.


              ROUND_UNNECESSARY: Yuvarlama modu, yuvarlama işleminin kesin bir sonucu olduğunu onaylar, bu nedenle yuvarlama gerekmez.

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


Dize belirli bir uzunluğa ulaşana kadar sağ tarafına sağlanan doldurma eklenir. Dize uzunluğuna eşit veya ondan büyükse, dize 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ırpıyor. Aksi takdirde, ikinci parametrede belirtilen herhangi bir karakteri kırpar.

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 veya America/Cayman biçiminde geçebilirsiniz. Yerel saat dilimi varsayılan olarak kullanılır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın.

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



seconds
seconds(<value1> : integer) => long


Saniye sayısı için milisaniye cinsinden süreyi verir.

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


Farklı temel veri türlerinden oluşan bir 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 bunu kullanabilirsiniz.

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



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


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

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ık derecesini 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. Pozisyon 1 temellidir. Uzunluk atlanırsa, varsayılan olarak dizenin sonuna ayarlanır.

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. İfade işlevi olarak sort ve #item1#item2 ardışık 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


Belirli ölçütlere göre bir sütunun standart sapmasını alır.

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ını hesaplar.

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


Bir sütunun örnek standart sapmasını, ölçütlere göre alma.

stddevSampleIf(region == 'West', sales)



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


Tarih veya saat damgasından günleri çıkarır. Tarih operatörüyle - aynı.

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



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


Ayları tarih veya saat damgasından çıkarır.

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, varsayılan olarak dizenin sonuna ayarlanır.

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(
              
              <dizeyi alt kümeye><sınırlayıcı>altDizeİndeks(: string, : string, <sınırlayıcı meydana gelme sayısı> : integral]) = dize>


Sınırlayıcının sayı oluşumlarından önce alt dizeyi ayıklar. Sayı pozitifse, soldan başlayarak son sınırlayıcının solundaki her şey döndürülür. Sayı negatifse, 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 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 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


Base64'te belirli bir dizeyi 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ı veya dizeyi ikili gösterime dönüştürür.

toBinary(3) -> [0x11]



toBoolean
toBoolean(<value1> : string) => boolean


(t, true, y, yes, 1) değerlerini true'ya ve (f, false, n, no, 0) değerlerini false'ya, diğer herhangi bir değeri ise NULL'ye 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 kullanabilirsiniz.

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'nın SimpleDateFormat sınıfına bakın. Giriş tarihi biçimi atlanırsa, varsayılan biçim olur yyyy-[M]M-[d]d. Kabul edilen biçimler şeklindedir :[ 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 kullanabilirsiniz. en-US, de veya zh-CNgibi bir BCP47 dili biçiminde isteğe bağlı bir yerel ayar biçimi kullanın.

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 kullanabilirsiniz. en-US, de veya zh-CNgibi bir BCP47 dili biçiminde isteğe bağlı bir yerel ayar biçimi kullanın.

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 kullanabilirsiniz. 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 kullanabilirsiniz. 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 kullanabilirsiniz. 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


Count bağımsız değişkenine göre bu sütun için en yüksek N değerleri 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 kullanabilirsiniz. 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 belirtebilirsiniz. Belirtilmezse, sistem varsayılanı seçilir. Sayılar için Java ondalık biçimi kullanılır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın. Varsayılan biçim şeklindedir yyyy-MM-dd. Tarih veya saat damgası için isteğe bağlı olarak bir yerel ayar belirtebilirsiniz.

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 verildiğinde 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 veya America/Cayman biçiminde geçebilirsiniz. 
              timestamp işlevi, değeriyle 999milisaniyeye kadar doğruluğu destekler. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın.

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 veya America/Cayman biçiminde geçebilirsiniz. Varsayılan olarak geçerli saat dilimini kullanır. Kullanılabilir biçimler için Java'nın SimpleDateFormat sınıfına bakın.

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. Karakterler bire bir eşleştirilir.

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ırpıyor. Aksi takdirde, ikinci parametrede belirtilen herhangi bir karakteri kırpar.

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



true
true() => boolean


Her zaman doğru bir değer döndürür. Bir sütunun adı true ise, syntax(true()) işlevini 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 kullanabilirsiniz. İşlev number kısa, tamsayı, uzun, çift, kayan veya ondalık ile eşleşir. İşlev integral kısa, tamsayı, uzun ile eşleşir. İşlev fractional çift, kayan, ondalık ile eşleşir. İşlev tarih datetime veya saat 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çimler için değişmez değerler json, xml, ecmascript, html ve java'dir.

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. Dizeden ikili gösterime dönüştürmek için ile sha2md5 kullanabilirsiniz.

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


İki 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 bir sütunun sapmasız varyansını alır.

varianceSampleIf(region == 'West', sales)


W

weekOfYear
weekOfYear(<value1> : datetime) => integer


Tarih verildiğinde yılın haftasını alır.

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



weeks
weeks(<value1> : integer) => long


Hafta sayısının süresini milisaniye olarak alır.

weeks(2) -> 1209600000L


X

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


Mantıksal XOR işlecini kullanır. İşleçle ^ 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

Tüm toplama işlevlerinin listesi.
Tüm dizi işlevlerinin listesi.
Önbelleğe alınmış tüm arama işlevlerinin listesi.
Tüm dönüştürme işlevlerinin listesi.
Tüm tarih ve saat işlevlerinin listesi.
Tüm ifade işlevlerinin listesi.
Tüm harita işlevlerinin listesi.
Tüm meta işlevlerin listesi.
Tüm pencere işlevlerinin listesi.

              İfade Oluşturucusu'nu kullanmayı öğrenin.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2025-11-19

Aracılığıyla paylaş

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

Tüm işlevlerin alfabetik listesi

A

abs

acos

add

addDays

addMonths

and

approxDistinctCount

array

ascii

asin

assertErrorMessages

associate

at

atan

atan2

avg

avgIf

B

between

bitwiseAnd

bitwiseOr

bitwiseXor

blake2b

blake2bBinary

byItem

byName

byNames

byOrigin

byOrigins

byPath

byPosition

C

case

cbrt

ceil

char

coalesce

collect

collectUnique

columnNames

columns

compare

concat

concatWS

contains

cos

cosh

count

countAll

countDistinct

countAllDistinct

countIf

covariancePopulation

covariancePopulationIf

covarianceSample

covarianceSampleIf

crc32

cumeDist

currentDate

currentTimestamp

currentUTC

D

dayOfMonth

dayOfWeek

dayOfYear

days

decode

degrees

denseRank

distinct

divide

dropLeft

dropRight

E

encode

endsWith

`abs`

`acos`

`add`

`addDays`

`addMonths`

`and`

`approxDistinctCount`

`array`

`ascii`

`asin`

`assertErrorMessages`

`associate`

`at`

`atan`

`atan2`

`avg`

`avgIf`

`between`

`bitwiseAnd`

`bitwiseOr`

`bitwiseXor`

`blake2b`

`blake2bBinary`

`byItem`

`byName`

`byNames`

`byOrigin`

`byOrigins`

`byPath`

`byPosition`

`case`

`cbrt`

`ceil`

`char`

`coalesce`

`collect`

`collectUnique`

`columnNames`

`columns`

`compare`

`concat`

`concatWS`

`contains`

`cos`

`cosh`

`count`

`countAll`

`countDistinct`

`countAllDistinct`

`countIf`

`covariancePopulation`

`covariancePopulationIf`

`covarianceSample`

`covarianceSampleIf`

`crc32`

`cumeDist`

`currentDate`

`currentTimestamp`

`currentUTC`

`dayOfMonth`

`dayOfWeek`

`dayOfYear`

`days`

`decode`

`degrees`

`denseRank`

`distinct`

`divide`

`dropLeft`

`dropRight`

`encode`

`endsWith`

`equals`

`equalsIgnoreCase`

`escape`

`except`

`expr`

`factorial`

`false`

`filter`