Power Query Dönüşümlerinizi Hızlandırın: Sütun Tiplerini Değiştirmek için Esnek Bir Fonksiyon

Veri dönüşümleri sırasında sütun tiplerini manuel olarak değiştirmekten sıkıldınız mı? Power Query’nin gücünü kullanarak, bu yorucu görevi otomatik ve esnek bir fonksiyona dönüştürmeye ne dersiniz? Bu makale, Power Query dönüşümlerinizi hızlandıracak, zamandan tasarruf sağlayacak ve hataları en aza indirecek özel bir M dili fonksiyonu oluşturma yolculuğuna çıkaracak.

Her gün yüzlerce hatta binlerce satır veriyle uğraşan herkes bilir ki, veri temizliği ve dönüşümü, analizin temelidir. Power Query, Excel ve Power BI kullanıcılarının veriyi alma, dönüştürme ve yükleme (ETL) süreçlerini basitleştiren güçlü bir araçtır. Ancak bu sürecin kritik bir parçası, verilerin doğru tiplerde olmasını sağlamaktır. Örneğin, bir tarih sütununun metin olarak okunması veya bir sayı sütununun hatalı karakterler içermesi, analizlerinizde ciddi sorunlara yol açabilir.

Veri tipleri neden bu kadar önemli? Öncelikle, performans açısından büyük fark yaratır. Power Query ve Power BI veri modelleri, doğru veri tiplerine sahip sütunlarla çok daha verimli çalışır. Metin olarak saklanan sayılar veya tarihler, gereksiz bellek tüketimine ve yavaş sorgu işlem sürelerine neden olabilir. İkinci olarak, veri doğruluğu ve analitik bütünlük için vazgeçilmezdir. Bir “tarih” sütunu metin olarak kalırsa, üzerinde tarih filtreleme, sıralama veya hesaplama gibi işlemleri yapamazsınız. Aynı şekilde, bir sayı sütunundaki metin değerleri, ortalama, toplam gibi matematiksel işlemleri imkansız kılar.

Power Query’nin kullanıcı arayüzü (UI) üzerinden sütun tiplerini değiştirmek oldukça kolaydır. Bir sütuna sağ tıklayıp “Tipi Değiştir” seçeneğini seçebilir veya sütun başlığındaki ikona tıklayarak istediğiniz tipi belirleyebilirsiniz. Ancak bu yöntem, veri setinizdeki sütun sayısı arttığında veya sürekli değişen veri kaynaklarıyla çalışırken ciddi bir darboğaz haline gelebilir. Onlarca, yüzlerce sütunun her birini tek tek manuel olarak değiştirmek hem zaman alıcı hem de hata yapmaya açık bir süreçtir. Ayrıca, yeni bir veri kaynağı geldiğinde veya mevcut bir kaynağın yapısında küçük bir değişiklik olduğunda, tüm bu adımları tekrar etmek zorunda kalırsınız. İşte tam da bu noktada, M dili ile yazılmış esnek bir fonksiyonun değeri ortaya çıkar. Bu fonksiyon, sütun tiplerini dinamik olarak yönetmenizi sağlayarak, tekrarlayan görevleri ortadan kaldırır ve veri dönüşüm süreçlerinizi otomatikleştirir. Bu da size daha kritik analizlere odaklanmak için daha fazla zaman ve enerji kazandırır.

Veri tiplerinin Power Query’deki rolünü ve önemini anlamak, daha sağlam ve verimli veri modelleri oluşturmanın ilk adımıdır. Power Query, çeşitli veri tiplerini destekler: Metin (Text), Sayı (Number), Tarih (Date), Saat (Time), Tarih/Saat (DateTime), Tarih/Saat/Saat Dilimi (DateTimeZone), Mantıksal (Logical – True/False), Para Birimi (Currency) ve İkili (Binary). Her bir tipin kendine özgü özellikleri ve kullanım alanları vardır. Örneğin, bir satış miktarını temsil eden sütunu “Metin” olarak bırakmak yerine “Sayı” (Decimal Number veya Whole Number) olarak ayarlamak, bu sütun üzerinde toplama, ortalama alma gibi istatistiksel hesaplamaları doğrudan yapabilmenizi sağlar. Tarih bilgileri için “Tarih” veya “Tarih/Saat” tipi kullanmak, takvim tabanlı analizler, dönemlik raporlamalar ve zaman serisi incelemeleri için hayati önem taşır. Yanlış veri tipleri, sadece hesaplama hatalarına değil, aynı zamanda görselleştirme araçlarında (Power BI gibi) hatalı grafik ve raporların oluşmasına da neden olabilir. Tüm bu nedenlerle, Power Query’de veri tiplerine hakim olmak, veri analiz yolculuğunuzda atacağınız en önemli adımlardan biridir.

Esnek Sütun Tipi Değiştirme Fonksiyonuna İhtiyaç Duyuyor muyuz?

Power Query’de veri dönüşümleri yaparken, çoğu zaman tekrarlayan görevlerle karşılaşırız. Bu görevlerin başında sütun tiplerini değiştirmek gelir. Diyelim ki, farklı kaynaklardan (CSV dosyaları, SQL veritabanları, API’ler) gelen ve benzer bir yapıya sahip onlarca tabloyu Power BI’a aktarıyorsunuz. Her bir tabloda “Tarih”, “Miktar”, “ID” gibi sütunların doğru veri tipine dönüştürülmesi gerekiyor. Eğer bu işlemi her tablo için manuel olarak yapmaya kalkarsanız, hem çok zaman kaybedersiniz hem de insan hatası riski artar. Bir tabloda “Tarih” sütununu doğru tipe dönüştürmeyi unutmanız veya yanlış bir tip seçmeniz, tüm analiz zincirini bozabilir.

Kullanıcı arayüzü (UI) tabanlı dönüşümlerin en büyük kısıtlılığı, dinamik olmamalarıdır. Eğer bir sütunun adı değişirse veya yeni bir sütun eklenirse, mevcut adımlarınız bozulabilir veya manuel müdahale gerektirebilir. Otomasyonun ve ölçeklenebilirliğin anahtarı, M dilinin gücünden yararlanmaktır. M dili, Power Query’nin arkasındaki güçlü formül dilidir ve bize, standart UI adımlarının ötesine geçerek özelleştirilmiş, esnek ve dinamik çözümler üretme imkanı sunar. İşte bu noktada, “Esnek Sütun Tipi Değiştirme Fonksiyonu” kavramı devreye girer. Bu tür bir fonksiyon, sadece bir veya iki sütunun değil, tablolarınızdaki istediğiniz sayıda sütunun tipini tek bir adımda ve parametreler aracılığıyla değiştirebilmenizi sağlar.

Bu fonksiyon, özellikle büyük ve karmaşık veri projelerinde, veri akışlarının (dataflows) tutarlılığını sağlamak için paha biçilmez bir araçtır. Diyelim ki bir veri ambarına veri yüklüyor ve staging alanında birçok geçici tabloyu işliyorsunuz. Her bir tablonun belirli sütunlarının aynı tipe sahip olması gerekiyorsa, bu esnek fonksiyonu kullanarak tüm bu dönüşümleri tek bir merkezi yerden yönetebilirsiniz. Bu, hem kod tekrarını azaltır hem de bakım maliyetlerini düşürür. Fonksiyonun parametre alabilme yeteneği sayesinde, farklı tablolar için farklı sütun/tip eşleşmeleri tanımlayabilir ve aynı fonksiyonu farklı senaryolarda kullanabilirsiniz. Bu, veri dönüşüm süreçlerinize gerçek anlamda bir çeviklik kazandırır. Örneğin, bir veri kaynağının “SiparişTarihi” sütununu “Date” (Tarih) tipine, başka bir kaynağın “OrderDate” sütununu da aynı şekilde “Date” tipine dönüştürmek isteyebilirsiniz. Fonksiyonunuzu, hangi sütunun hangi tipe dönüştürüleceğini belirten bir liste veya tablo alacak şekilde tasarlayarak, bu esnekliği kolayca sağlayabilirsiniz. Bu, veri dönüşüm süreçlerinizi sadece hızlandırmakla kalmaz, aynı zamanda gelecekteki değişikliklere karşı daha dirençli hale getirir.

Adım Adım Kılavuz: Esnek Fonksiyonumuzu Nasıl Oluştururuz?

Şimdi, Power Query’deki veri dönüşümlerimizi bir üst seviyeye taşıyacak o esnek M fonksiyonunu nasıl oluşturacağımıza dair adım adım bir rehbere dalalım. Amacımız, sadece birkaç sütun için değil, onlarca hatta yüzlerce sütun için dinamik olarak tip değişikliği yapabilen, tekrar kullanılabilir bir fonksiyon yazmak.

Fonksiyonun Temel Fikri Nedir?

M dilinde, sütun tiplerini değiştirmek için Table.TransformColumnTypes adında güçlü bir yerleşik fonksiyon bulunur. Bu fonksiyon, bir tabloyu ve dönüştürülecek sütunların adlarını ve hedef tiplerini içeren bir listeyi argüman olarak alır. Bizim esnek fonksiyonumuz ise, bu listeyi dinamik olarak oluşturacak ve Table.TransformColumnTypes‘ı çağıracak bir sarmalayıcı (wrapper) olacaktır. Böylece, her seferinde kodu baştan yazmak yerine, sadece fonksiyonumuzu çağırıp parametrelerini güncelleyeceğiz.

Adım 1: Boş Bir Sorgu Oluşturma

Power BI veya Excel’de Power Query düzenleyicisini açın. Sol taraftaki “Sorgular” bölmesinde boş bir alana sağ tıklayın, “Yeni Sorgu” -> “Boş Sorgu” seçeneğini seçin. Bu, bizim özel M fonksiyonumuzu yazacağımız yer olacak.

Adım 2: Fonksiyon Kodunu Yazma

Boş sorguyu açtıktan sonra, “Gelişmiş Düzenleyici”ye (Advanced Editor) gidin. İşte fonksiyonumuzun temel yapısı:

  (inputTable as table, typeTransformList as list) as table =>
  let
      // Her bir öğe {SutunAdı, HedefTip} formatında bir liste içerir.
      // Örneğin: {{"SiparişTarihi", type date}, {"Miktar", type number}}
      ChangedTypes = Table.TransformColumnTypes(inputTable, typeTransformList)
  in
      ChangedTypes

Bu kod bloğunu Gelişmiş Düzenleyici'ye yapıştırın ve sorgunuzun adını örneğin fnChangeColumnTypes olarak değiştirin.

Fonksiyonun Detaylı Açıklaması:

• inputTable as table: Fonksiyonumuzun ilk parametresi, üzerinde işlem yapacağımız tablonun kendisidir. Tip olarak table bekleriz.
• typeTransformList as list: Bu, dönüştürülecek sütunları ve onların hedef tiplerini tanımlayan bir listedir. Her bir liste öğesi, {SütunAdı, HedefTip} şeklinde bir iç liste olmalıdır. Örneğin: {"SiparişNo", type text} veya {"Miktar", type number}. type text, type number, type date, type datetime gibi M dili tiplerini kullanırız.
• Table.TransformColumnTypes(inputTable, typeTransformList): İşte tüm büyüyü gerçekleştiren ana fonksiyon budur. Verdiğimiz tabloyu ve tip dönüşüm listesini kullanarak sütun tiplerini değiştirir.

Adım 3: Fonksiyonu Kullanma

Fonksiyonumuzu oluşturduktan sonra, onu herhangi bir Power Query sorgusunda çağırabiliriz. Diyelim ki Satışlar adında bir tablonuz var ve bu tabloda SiparişTarihi (metin olarak gelmiş), SiparişMiktarı (metin olarak gelmiş) ve BirimFiyat (metin olarak gelmiş) sütunlarını doğru tiplere dönüştürmek istiyorsunuz.

  let
      Kaynak = Excel.CurrentWorkbook(){[Name="Satışlar"]}[Content],
      // Dönüşüm listemizi oluşturuyoruz
      DonusumListesi = {
          {"SiparişTarihi", type date},
          {"SiparişMiktarı", type number},
          {"BirimFiyat", type currency},
          {"MüşteriID", type text} // Örnek olarak bir de metin tipi ekleyelim
      },
      // Fonksiyonumuzu çağırıyoruz
      DonusturulmusTablo = fnChangeColumnTypes(Kaynak, DonusumListesi)
  in
      DonusturulmusTablo

Bu kodda, DonusumListesi adlı bir liste tanımladık. Bu liste, fnChangeColumnTypes fonksiyonumuzun typeTransformList parametresine aktarılır. Fonksiyon, Kaynak tablosunu alır ve bu listeye göre sütun tiplerini otomatik olarak değiştirir. Artık, yüzlerce sütunlu bir tablonuz olsa bile, sadece bu dönüşüm listesini güncelleyerek saniyeler içinde tüm sütun tiplerini değiştirebilirsiniz. Bu yöntem, hem zaman kazandırır hem de veri dönüşüm süreçlerinizi standartlaştırarak hata oranını ciddi şekilde düşürür. Ayrıca, bir tablonun sütun yapısı değiştiğinde, sadece DonusumListesi'ni güncellemeniz yeterli olacaktır, Power Query arayüzündeki onlarca adımı tek tek düzeltmeye gerek kalmaz.

Bu fonksiyon, Power Query'nin sunduğu dinamik ve esnek dönüşüm yeteneklerinin sadece küçük bir örneğidir. Fonksiyonları kullanarak, tekrarlayan görevleri otomatikleştirebilir, kodunuzu daha okunabilir ve yönetilebilir hale getirebilirsiniz. Gelecek bölümlerde, bu fonksiyonu daha da geliştirerek farklı senaryolara nasıl adapte edebileceğimizi inceleyeceğiz.

Uzman İpucu: M dilinde "type any" genel bir tiptir ve herhangi bir değeri temsil eder. Ancak performans ve doğruluk için mümkünse her zaman daha spesifik tipleri (type date, type number vb.) kullanmaya özen gösterin.

Gerçek Dünya Senaryosu: Birden Fazla Tabloyu Tek Bir Fonksiyonla Dönüştürmek

Tek bir tablo üzerinde sütun tiplerini değiştirmek güzel, ancak gerçek dünya projelerinde genellikle birden fazla tabloyla, hatta onlarca tabloyla çalışırız. Bu tabloların çoğu zaman benzer sütun isimleri ve benzer veri türü ihtiyaçları olur. İşte bu noktada, oluşturduğumuz esnek fonksiyonun gerçek gücü ortaya çıkar. Hayal edin: Bir e-ticaret şirketinin aylık satış verilerini, her ay ayrı bir CSV dosyasında aldığınızı düşünün. Her dosyanın içinde "OrderDate", "Quantity", "UnitPrice", "CustomerID" gibi sütunlar var ve her biri metin olarak geliyor. Her ay yeni bir dosya geldiğinde, her bir sütunu manuel olarak dönüştürmek yerine, tek bir fonksiyonla tüm bu tabloları standart hale getirebiliriz.

Vaka Analizi: Aylık Satış Raporlarının Standardizasyonu

Problem: Her ay gelen yeni CSV dosyaları (örneğin, "Satışlar_202301.csv", "Satışlar_202302.csv" vb.) Power Query'ye aktarıldığında, "OrderDate" sütunu metin, "Quantity" ve "UnitPrice" sütunları metin ve "CustomerID" sütunu da metin olarak geliyor. Bu sütunları her seferinde manuel olarak dönüştürmek zaman alıcı ve hataya açık.

Çözüm: Oluşturduğumuz fnChangeColumnTypes fonksiyonunu kullanarak tüm bu tabloları otomatik olarak dönüştüreceğiz. Öncelikle, tüm CSV dosyalarını Power Query'ye aktarmanın bir yolunu bulmalıyız (örneğin, bir klasördeki tüm dosyaları birleştirmek).

  let
      // 1. Klasördeki tüm CSV dosyalarını al
      KaynakKlasor = Folder.Files("C:\Veri\AylikSatislar"),
      
      // 2. Her bir dosyayı oku ve içeriğini tablo olarak al
      OkunmusDosyalar = Table.AddColumn(KaynakKlasor, "DosyaIcerigi", each Csv.Document([Content], [Delimiter=",", Columns=6, Encoding=65001, QuoteStyle=QuoteStyle.Csv])),
      
      // 3. İhtiyacımız olmayan sütunları kaldır ve sadece dosya içeriğini tut
      KaldırılanDigerSutunlar = Table.SelectColumns(OkunmusDosyalar, {"Name", "DosyaIcerigi"}),
      
      // 4. Dönüşüm listemizi tanımla (tüm tablolar için geçerli olacak)
      DonusumListesi = {
          {"OrderDate", type date},
          {"Quantity", type number},
          {"UnitPrice", type currency},
          {"CustomerID", type text}
      },
      
      // 5. Her bir tablonun sütun tiplerini fonksiyonumuzu kullanarak dönüştür
      // Table.TransformColumnTypes yerine fnChangeColumnTypes'ı çağırıyoruz.
      DonusturulmusTablolar = Table.AddColumn(KaldırılanDigerSutunlar, "DonusturulmusTablo", each fnChangeColumnTypes([DosyaIcerigi], DonusumListesi)),
      
      // 6. Orijinal dosya içeriği sütununu kaldır ve dönüştürülmüş tabloyu genişlet
      KaldırılanOrijinalIcerik = Table.RemoveColumns(DonusturulmusTablolar, {"DosyaIcerigi"}),
      GenisletilmisTablo = Table.ExpandTableColumn(KaldırılanOrijinalIcerik, "DonusturulmusTablo", {"OrderDate", "Quantity", "UnitPrice", "CustomerID"}, {"OrderDate", "Quantity", "UnitPrice", "CustomerID"})
  in
      GenisletilmisTablo

Yukarıdaki M kodu bloğunu inceleyelim:

1. Öncelikle Folder.Files ile belirli bir klasördeki tüm dosyaları alıyoruz.
2. Ardından, Csv.Document kullanarak her bir dosyanın içeriğini okuyup bir tabloya dönüştürüyoruz. Bu adımda sütun tipleri henüz metin olarak kalır.
3. DonusumListesi adında, tüm tablolarımız için geçerli olacak standart bir dönüşüm listesi tanımlıyoruz.
4. En kritik adım: Table.AddColumn ile yeni bir sütun ekleyip, bu sütunda her bir dosya içeriği tablosu için fnChangeColumnTypes fonksiyonumuzu çağırıyoruz. Bu, her bir alt tablonun sütun tiplerini belirlediğimiz listeye göre dönüştürür.
5. Son olarak, orijinal içeriği kaldırıp dönüştürülmüş tabloları genişleterek tek, birleşik bir tablo elde ediyoruz.

Bu senaryo, tek bir fnChangeColumnTypes fonksiyonunun ne kadar güçlü olabileceğini gösteriyor. Artık, yeni bir ayın verisi geldiğinde, yapmanız gereken tek şey CSV dosyasını C:\Veri\AylikSatislar klasörüne atmak ve Power Query'yi yenilemek. Tüm sütun tipi dönüşümleri otomatik olarak ve tutarlı bir şekilde gerçekleşecektir. Bu yöntem, sadece zamandan tasarruf etmekle kalmaz, aynı zamanda veri dönüşüm süreçlerinizde tutarlılık ve güvenilirlik sağlar.

Uzman İpucu: Fonksiyonunuzu parametrelendirerek çok daha dinamik hale getirebilirsiniz! Örneğin, farklı kaynaklardan gelen tablolarda aynı anlama gelen ancak farklı adlara sahip sütunları (örn. "SiparişTarihi" ve "OrderDate") tek bir dönüşüm listesiyle eşleştirmek için fonksiyonunuzu geliştirebilirsiniz. Bu, M dilinde daha karmaşık "mapping" tabloları oluşturarak yapılabilir.

Bu yaklaşım, özellikle büyük ölçekli ve sürekli güncellenen veri ortamlarında veri mühendisleri ve analistler için vazgeçilmezdir. Manuel işlemlerin yerine otomatize edilmiş, esnek fonksiyonlar koymak, veri hazırlık sürecini modernleştirmenin ve geleceğe hazır hale getirmenin en etkili yollarından biridir. Ayrıca, bu tür bir yapı, veri kalitesi standartlarını yükseltmenize ve raporlama süreçlerinizin güvenilirliğini artırmanıza da yardımcı olur.

Daha İleriye Gitmek: Gelişmiş Özelleştirmeler ve Hata Yönetimi

Oluşturduğumuz temel fonksiyon harika bir başlangıç noktası. Ancak gerçek dünya verileri nadiren bu kadar temiz ve düzgün gelir. Gelişmiş senaryolar, dinamik sütun adları, yerel ayarlar (locale) ve hata yönetimi gibi ek özellikler gerektirebilir. Şimdi, fonksiyonumuzu daha sağlam ve esnek hale getirmek için bazı ileri düzey tekniklere bakalım.

Koşullu Tip Değişiklikleri ve Hata Yönetimi

Bazen bir sütun, beklediğimiz tipte olmayan değerler içerebilir. Örneğin, bir sayı sütununda "N/A" veya boş metinler olabilir. Table.TransformColumnTypes varsayılan olarak bu durumda hata fırlatır. Bunu yönetmek için M dilindeki try...otherwise yapısını kullanabiliriz.

  // Örnek: Bir metni sayıya dönüştürürken hata yönetimi
  TextToNumberWithNull = (textValue as text) as nullable number =>
      try Number.From(textValue) otherwise null;

  // Fonksiyonunuzda bu mantığı uygulamak için
  // typeTransformList'i güncelleyebilirsiniz:
  // {"Miktar", TextToNumberWithNull} şeklinde doğrudan kullanamayız,
  // çünkü Table.TransformColumnTypes M tipi bekler.
  // Bunun yerine, her sütun için ayrı ayrı Try...Otherwise adımı uygulayabiliriz
  // veya daha karmaşık bir fonksiyon yazabiliriz.
  // Pratik ve okunabilir bir yaklaşım için:
  let
      Kaynak = MyTable,
      // Miktar sütununu sayıya dönüştür, hata olursa null yap
      MiktarDonusum = Table.TransformColumns(Kaynak, {{"Miktar", each try Number.From(_) otherwise null, type nullable number}}),
      // Diğer sütunlar için normal tip dönüşümü yap
      // ...
  in
      MiktarDonusum

Bu yaklaşım, her sütun için ayrı ayrı Table.TransformColumns kullanmayı gerektirebilir, bu da tek fonksiyonumuzun esnekliğini azaltır. Daha gelişmiş bir fnChangeColumnTypes sürümü, typeTransformList içinde bir hata işleme stratejisi belirtecek ek bir parametre alabilir veya her dönüşümü bir try...otherwise sarmalayıcı içinde gerçekleştirebilir. Ancak bu, fonksiyonun karmaşıklığını önemli ölçüde artıracaktır.

Dinamik Sütun Algılama ve Varsayılan Tipler

Ya sütun adları sürekli değişiyorsa veya sadece belirli bir desenle eşleşen sütunları dönüştürmek istiyorsak? Table.ColumnNames fonksiyonu, bir tablonun tüm sütun adlarını dinamik olarak almanızı sağlar. Bunu kullanarak, dönüşüm listemizi dinamik olarak oluşturabiliriz.

  (inputTable as table, optional typeMap as list) as table =>
  let
      // Varsayılan dönüşüm listesi, eğer typeMap sağlanmazsa
      DefaultTypeMap = {
          {"ID", type text},
          {"Miktar", type number},
          {"Tarih", type date}
      },
      // Eğer typeMap sağlanmışsa onu kullan, yoksa varsayılanı kullan
      ActualTypeMap = if typeMap = null then DefaultTypeMap else typeMap,
      
      // Sütunların mevcut adlarını al
      AvailableColumns = Table.ColumnNames(inputTable),
      
      // Dönüşüm listemizdeki her bir öğe için, eğer sütun tablomuzda varsa, onu dahil et
      FilteredTypeMap = List.Select(ActualTypeMap, each List.Contains(AvailableColumns, Record.Field(_, 0))),
      
      // M tipi dönüşüm formatına getir ({"SutunAdi", Type})
      FinalTypeTransformList = List.Transform(FilteredTypeMap, each {Record.Field(_, 0), Record.Field(_, 1)}),
      
      ChangedTypes = if List.IsEmpty(FinalTypeTransformList) then inputTable else Table.TransformColumnTypes(inputTable, FinalTypeTransformList)
  in
      ChangedTypes

Bu fonksiyon, artık isteğe bağlı bir typeMap alıyor. Eğer sağlanmazsa, önceden tanımlanmış bir DefaultTypeMap kullanır. Ayrıca, tabloda bulunmayan sütunlar için dönüşüm yapmaya çalışmaz, bu da hataları önler.

Yerel Ayar (Locale) Farkındalığı

Sayılar ve tarihler, farklı bölgelerde farklı formatlarda yazılabilir. Örneğin, "12.345,67" Avrupa'da bir sayı iken, ABD'de "12,345.67" şeklinde yazılır. Power Query'de Table.TransformColumnTypes fonksiyonu, isteğe bağlı üçüncü bir parametre olarak locale bilgisi alabilir.

  // Mevcut fonksiyonumuzu bu şekilde güncelleyebiliriz:
  (inputTable as table, typeTransformList as list, optional locale as text) as table =>
  let
      // Eğer locale sağlanmamışsa, varsayılan bir değer kullanabiliriz veya boş bırakabiliriz
      EffectiveLocale = if locale = null then Culture.Current else locale,
      
      // Her bir tip dönüşümü için locale bilgisini ekleyerek yeni bir liste oluştur
      // Table.TransformColumnTypes'ın formatı her bir öğe için {sutun_adı, yeni_tip, locale} şeklindedir.
      FormattedTransformList = List.Transform(typeTransformList, each 
          if List.Contains({type number, type date, type datetime, type datetimezone, type currency}, List.Last(_)) // Sadece sayısal ve tarihsel tipler için locale ekle
          then {List.First(_), List.Last(_), EffectiveLocale} 
          else {List.First(_), List.Last(_)}
      ),
      
      ChangedTypes = Table.TransformColumnTypes(inputTable, FormattedTransformList)
  in
      ChangedTypes

Artık fonksiyonumuz, bir locale parametresi alarak, sayı ve tarih dönüşümlerinde bölgesel farklılıkları da göz önünde bulundurabilir. Örneğin, fnChangeColumnTypes(MyTable, DonusumListesi, "en-US") veya fnChangeColumnTypes(MyTable, DonusumListesi, "tr-TR") şeklinde çağırabilirsiniz.

Performans Düşünceleri

Büyük veri setleriyle çalışırken, her adımın performansa etkisi olabilir. Fonksiyonlarımızı mümkün olduğunca verimli yazmaya çalışmalıyız. Özellikle dinamik sütun algılama gibi adımlar, her çağrıldığında tablonun sütunlarını yeniden okuyacağı için küçük bir ek yük getirebilir. Ancak genel olarak, tek bir Table.TransformColumnTypes çağrısı, arayüzden yapılan bir dizi ayrı adımdan genellikle daha verimlidir çünkü Power Query motoru bu tür toplu işlemleri daha iyi optimize edebilir. Karmaşık koşullu dönüşümlerde (örn. try...otherwise her hücre için ayrı ayrı çalıştırıldığında), performans biraz düşebilir. Bu gibi durumlarda, önce veriyi filtreleyip temizleyerek dönüşümün sadece temizlenmiş veri üzerinde yapılmasını sağlamak veya daha optimize edilmiş M dilindeki yerleşik fonksiyonları kullanmak faydalı olabilir.

Uzman İpucu: Büyük veri setlerinde dönüşüm adımlarını optimize etmek performansı kritik düzeyde etkiler. Dönüşüm listesini mümkün olduğunca sabit tutmaya çalışın ve gereksiz yere dinamik hesaplamalardan kaçının. Ayrıca, Table.Buffer gibi fonksiyonları kullanarak ara tabloları belleğe alarak performansı artırabilirsiniz, ancak bunu yaparken bellek tüketimine dikkat edin.

Bu ileri düzey tekniklerle, Power Query dönüşüm fonksiyonunuzu çok daha sağlam, uyarlanabilir ve hata toleranslı hale getirebilirsiniz. Bu, karmaşık veri entegrasyonu ve hazırlık projelerinde size önemli bir avantaj sağlayacaktır.

Mobil Uyumlu HTML ve Neden Önemli?

Bu teknik makale Power Query üzerine olsa da, içerik tüketimi bağlamında mobil uyumluluk her türlü dijital içerik için vazgeçilmez bir konudur. Okuyucuların makalelerinize farklı cihazlardan (masaüstü, tablet, telefon) erişebileceğini göz önünde bulundurarak, sunduğunuz HTML içeriğinin mobil uyumlu olması, kullanıcı deneyimi açısından kritik öneme sahiptir.

Neden Mobil Uyumlu HTML?

• Geniş Kitleye Erişilebilirlik: Artık çoğu internet trafiği mobil cihazlar üzerinden gerçekleşiyor. İçeriğiniz mobil uyumlu değilse, potansiyel okuyucuların büyük bir kısmına ulaşamayabilirsiniz.
• Kullanıcı Deneyimi: Mobil cihazlarda okunması zor, yanlara kaydırma gerektiren veya küçük metinli sayfalar, kullanıcıları hızla siteden uzaklaştırır. İyi bir kullanıcı deneyimi, okuyucunun içeriğinize odaklanmasını sağlar.
• SEO Avantajı: Arama motorları (özellikle Google), mobil uyumlu siteleri sıralamada öncelikli tutar. Responsive tasarım, SEO performansınız için doğrudan bir etkendir.
• Profesyonel İmaj: Teknik içerik sunan bir platformun veya yazarın mobil uyumluluğu göz ardı etmesi, profesyonellikten uzak bir imaj çizebilir.

HTML İçeriğinde Mobil Uyumluluk Nasıl Sağlanır?

Temel olarak, HTML içeriğinizin mobil uyumlu olması için CSS ve meta etiketlerinden yararlanılır. Bir makale içeriği sunarken, bu etiketlerin HTML sayfanızın bölümünde doğru şekilde ayarlandığından emin olmak gerekir.

Viewport Meta Etiketi

En temel adım, tarayıcıya sayfanın genişliğini cihazın genişliğine göre ayarlamasını söyleyen viewport meta etiketidir. Bu etiket, genellikle bir web sayfasının bölümünde yer alır:

• width=device-width: Sayfanın genişliğini cihazın ekran genişliğiyle eşleştirir.
• initial-scale=1.0: Sayfa ilk yüklendiğinde varsayılan yakınlaştırma düzeyini ayarlar.

Esnek Düzen ve İçerik

HTML içeriğinizdeki öğelerin (resimler, tablolar, metin blokları) esnek olması önemlidir. Genişliği sabit piksel değerleriyle ayarlamak yerine, yüzde değerleri (width: 100%;) veya max-width gibi özellikler kullanmak, içeriklerin farklı ekran boyutlarına uyum sağlamasına yardımcı olur.

Medya Sorguları (Media Queries)

CSS medya sorguları, belirli ekran genişliklerine, cihaz tiplerine veya yönelimlerine göre farklı stil kuralları uygulamanıza olanak tanır. Örneğin, mobil cihazlarda sütunları üst üste yığmak veya font boyutlarını küçültmek isteyebilirsiniz.

  /* Genel stil kuralları (masaüstü için optimize edilmiş olabilir) */
  body {
      font-size: 16px;
      line-height: 1.6;
  }
  .container {
      width: 960px;
      margin: 0 auto;
  }

  /* Mobil cihazlar için stil kuralları (ekran genişliği 768px veya daha az ise) */
  @media only screen and (max-width: 768px) {
      body {
          font-size: 14px;
      }
      .container {
          width: 100%;
          padding: 10px;
      }
      h2 {
          font-size: 20px;
      }
      /* Kod blokları için yatay kaydırma çubuğu */
      pre {
          overflow-x: auto;
          white-space: pre-wrap; /* Uzun satırları otomatik kırar */
          word-wrap: break-word; /* Uzun kelimeleri de kırar */
      }
  }

Bu örnek, max-width: 768px altındaki ekranlarda font boyutunu küçültür ve .container sınıfına sahip öğenin genişliğini tam ekrana yayar. pre etiketi için eklenen overflow-x: auto özelliği, kod bloklarının mobil cihazlarda ekran dışına taşmasını engeller ve yatay kaydırma çubuğu sağlar, böylece kodun tamamı görüntülenebilir olur.

Sonuç olarak, hazırladığınız Power Query makalesinin kendisi ne kadar teknik ve detaylı olursa olsun, bu içeriğin farklı cihazlarda kolayca okunabilir ve tüketilebilir olması, bilginin etkin bir şekilde aktarılması için hayati önem taşır. Mobil uyumluluk, günümüz dijital dünyasında sadece bir lüks değil, bir gerekliliktir.

Sonuç: Dönüşümlerinizi Gerçekten Hızlandırın!

Bu makale boyunca, Power Query'nin gücünü kullanarak sütun tipi dönüşümlerini nasıl otomatikleştirebileceğimizi ve esnek bir M fonksiyonu aracılığıyla nasıl daha verimli hale getirebileceğimizi ayrıntılı olarak inceledik. Gördük ki, manuel ve tekrarlayan görevler yerine M dilinin dinamik yeteneklerinden faydalanmak, veri hazırlık süreçlerimizi hızlandırırken, insan kaynaklı hataları minimuma indiriyor ve genel veri kalitemizi artırıyor.

Oluşturduğumuz fnChangeColumnTypes fonksiyonu, sadece bir başlangıç noktası. Onu yerel ayar desteğiyle zenginleştirdik, hata yönetimi stratejileri üzerine düşündük ve dinamik sütun algılama yetenekleri ekleyerek daha da güçlü hale getirdik. Bu araçlar, özellikle çok sayıda veri kaynağıyla çalışan, sürekli değişen veya büyüyen veri setlerini yöneten analistler ve veri mühendisleri için paha biçilmez birer yardımcıdır. Artık Power Query'deki rutin sütun tipi değişiklikleri, tek bir fonksiyon çağrısıyla anında ve tutarlı bir şekilde gerçekleşebilir.

Power Query'nin sunduğu bu esneklik, sadece zaman kazandırmakla kalmaz, aynı zamanda veri dönüşüm iş akışlarınızda bir standartlaşma sağlar. Herkesin aynı fonksiyonu kullanması, veri modelinizin tutarlılığını garanti eder ve hatalı veri tipleri nedeniyle ortaya çıkabilecek karmaşık sorunların önüne geçer. Bu sayede, daha az veri temizliğiyle uğraşarak, daha fazla zamanı verileri analiz etmeye ve iş değeri oluşturmaya ayırabilirsiniz. Unutmayın, M dili sonsuz olanaklar sunar ve bu makalede öğrendikleriniz, kendi yaratıcı çözümlerinizi geliştirmek için size ilham verecektir. Deney yapmaktan çekinmeyin ve Power Query dönüşümlerinizi gerçekten "süper şarj edin"!

Sıkça Sorulan Sorular (SSS)

1. Bu fonksiyon sadece belirli bir veri kaynağı için mi geçerli?

   Hayır, oluşturduğumuz fnChangeColumnTypes fonksiyonu, Power Query'nin desteklediği herhangi bir tablo yapısındaki veri kaynağı (Excel, CSV, Veritabanı, API vb.) için kullanılabilir. Fonksiyon, kendisine iletilen Power Query tablosu üzerinde işlem yapar, kaynağın türünden bağımsızdır.

2. Performans üzerinde bir etkisi var mı?

   Genellikle, bu tür optimize edilmiş bir M fonksiyonu, Power Query arayüzünden yapılan manuel adımlardan daha iyi veya en azından eşdeğer performans sunar. Özellikle çok sayıda sütunun tek seferde dönüştürülmesi gerektiğinde, Table.TransformColumnTypes gibi yerleşik fonksiyonlar toplu işlemleri verimli bir şekilde gerçekleştirir. Ancak, karmaşık hata yönetimi veya her satırda özel dönüşümler içeren çok dinamik fonksiyonlar, çok büyük veri setlerinde küçük bir ek yük getirebilir.

3. Hata alırsam ne yapmalıyım?

   Hata almanız durumunda, öncelikle dönüşüm listenizi (typeTransformList) kontrol edin. Sütun adlarının doğru yazıldığından ve hedef tiplerin (type date, type number vb.) M diline uygun olduğundan emin olun. Ayrıca, veri kaynağınızdaki değerlerin, hedef tipe dönüştürülebilecek formatta olup olmadığını doğrulayın. Örneğin, bir metin "ABC" değerini type number'a dönüştürmeye çalışmak hataya yol açacaktır. Hata yönetimi için makalede bahsedilen try...otherwise yaklaşımını uygulayabilirsiniz.

4. Bu fonksiyonu Power BI ve Excel'de kullanabilir miyim?

   Evet, kesinlikle! Power Query, hem Power BI Desktop'ın hem de Excel'in güçlü bir parçasıdır. Bu makalede oluşturduğumuz M dili fonksiyonunu her iki platformdaki Power Query düzenleyicisinde de tanımlayabilir ve kullanabilirsiniz. Kod tamamen aynı şekilde çalışacaktır.

5. Tüm sütunları otomatik olarak metne dönüştürmek mümkün mü?

   Evet, tüm sütunları metne dönüştürmek için de benzer bir dinamik yaklaşım kullanabilirsiniz. Öncelikle Table.ColumnNames ile tablodaki tüm sütun adlarını alın, ardından bu liste üzerinde döngü yaparak her sütun için hedef tip olarak type text belirten bir dönüşüm listesi oluşturup Table.TransformColumnTypes'a iletebilirsiniz.