Marcin Molak - w bezmiarze informacji

Źródła wiedzy - IBM DB2

2011-07-11T09:57:00.003+02:00

W poprzednim poście poruszyłem kwestie dokumentacji produktów IBM. Mimo, że są one najdokładniejszym (a przynajmniej powinny takim być) i użytecznym źródłem wiedzy, wielu z nas poszukuje łatwiej przyswajalnych alternatyw.
O takie często pytany byłem w przypadku serwera IBM DB2. Jak się okazuje jest wiele (i to bezpłatnych) źródeł wiedzy dotyczących tego produktu. Poniżej przedstawiona jest ich lista:

- polskie wydania magazynów SDJ Extra!:
- SDJ Extra! - DB2 9
- SDJ Extra! - DB2 9.7
- książki z serii Najlepsze praktyki DB2
- książka DB2 SQL Cookbook

- blog Poznaj DB2
- blog DB2 UDE
- portal Channel DB2

- książki z serii Getting started
Wśród nich można znaleźć polską edycję "Wprowadzenie do DB2 Express-C 9.5", przygotowaną przez studentów Uniwersytetu im. Adama Mickiewicza w Poznaniu pod opieką Marcina Marczewskiego, kierownika zespołu migracyjnego w Laboratorium IBM.
- magazyn IBM Data Management
- dział Information Management na portalu Developerworks
- książki z serii IBM RedBooks

Wśród płatnych publikacji warto wyróżnić:
- książki Rogera Sandersa przygotowujące do certyfikatów IBM; Roger jest nota bene współautorem egzaminów z dziedziny administracji i programowania DB2
- książkę Understanding DB2 zespołu w składzie: Raul F. Chong, Xiaomei Wang, Michael Dang, Dwaine R. Snow (w Polsce wydano również pierwszą edycje tej książki pod nazwą Zrozumieć DB2, jednak dotyczy ona już niewspieranej wersji 8 motoru)

Dla klientów i business partnerów IBM dostępne są również bezpłatne warsztaty IBM Bootcamps. Ich listę można zobaczyć na stronie.
Dodatkowo dział oprogramowania IBM Polska często organizuje niezależne warsztaty, np. Zostań ekspertem DB2.

O dokumentacjach IBM słów kilka

2011-07-11T09:01:00.013+02:00

Często w naszej pracy z produktami podstawowe źródło wiedzy stanowią ich dokumentacje. Nie inaczej wygląda pozyskiwanie informacji na temat oprogramowania sygnowanego marką IBM. Co więcej, Centra informacyjne stanowią tak wygodny interfejs dostępu, że ich omówienie jest niekiedy elementem szkolenia (np. najlepszych moim zdaniem szkoleń Artura Wrońskiego na temat DB2).
Aby znaleźć dokumentację interesującego nas produktu w ramach dowolnej wyszukiwarki wpisujemy jego nazwę dołączając frazę Information Center. Dla przykładu będziemy posługiwać się dokumentacją najbliższego mi produktu IBM, czyli DB2. Wpiszmy zatem IBM DB2 9.7 Information Center. Powinniśmy wówczas otrzymać rezultat podobny do poniższego:

Wybieramy pierwszą pozycję, to jest odnośnik z adresem http://publib.boulder.ibm.com/infocenter/db2luw/v9r7/index.jsp. Zanim jednak przejdziemy do omówienia interfejsu dokumentacji i jego użytecznych funkcji, warto pokusić się o pewną uwagę. W ramach adresu dokumentacji (prawie) każdego produktu określana jest jego wersja. W naszym przypadku widzimy zapis v9r7 co odpowiada wersji 9.7. Zmieniając go na v9 czy v9r5 możemy w łatwy sposób zmienić wcześniejszą wersję motoru danych.

Niezależnie jednak od wersji (a nawet od produktu) otrzymujemy jednak taki sam, oparty na platformie Eclipse, interfejs:

Po jego lewej stronie mamy zakładki ze spisem treści, indeksem oraz wynikami wyszukiwania. Po prawej zaś obszar treści z paskiem narzędzi. Zarówno lokalizacja interfejsu jak i samej zawartości są ściśle powiązane z ustawieniami językowymi przeglądarki. W przypadku języka polskiego należy jednak liczyć się z faktem, że nie wszystko jest obecnie przetłumaczone. Najczęściej jednak wszyscy i tak zmieniają język na angielski.

Wyszukajmy w dokumentacji informacje o poleceniu db2look i z otrzymanych wyników wybierzmy pierwszą pozycje:

Widzimy, że wszystkie wystąpienia wyszukanej frazy są podświetlone w ramach treści. Czasem powoduje to jednak zmniejszenie czytelności wyświetlanego tekstu. Dlatego posłużymy się ikoną markera z paska narzędzi. Jednocześnie wybierzmy opcję wyszukania obecnie wyświetlanego tematu w spisie treści:

Otrzymamy widok podobny do poniższego:

Funkcjonalność wyszukiwania elementu w spisie treści wykorzystywana może być w przypadku, gdy nie potrzebujemy znaleźć element, którego nazwę zapomnieliśmy. W naszym przykładzie wyświetlenie komendy db2look w spisie treści umożliwia znalezienie potrzebnego nam w danej chwili polecenia administracyjnego.

Ostatnią kwestią jest przekazywanie hiperłącza do konkretnego elementu dokumentacji. W tej kwestii musimy otworzyć ten element korzystając z opcji Otwórz w nowej zakładce (nowym oknie) bądź użyć opcji Kopiowania łącza w przeglądarce. W przeciwnym wypadku skopiujemy początkowy adres dokumentacji produktu.

Być może ktoś z Was zna jeszcze inne ciekawe funkcje dokumentacji IBM. Czekam na komentarze.

Reaktywacja i zmiany...

2011-07-05T09:04:00.003+02:00

"Jak ten czas leci" - tymi słowami chciałoby się podsumować przerwę w aktywności autora niniejszego blogu. Przerwę, która u wielu osób - z autorem włącznie - wywołała poczucie, iż nowe posty nie pojawią się już nigdy.

W przyrodzie nic jednak nie ginie i również ten blog przeżywa swoją reinkarnacje. Nowe doświadczenia autora z zakresu zarządzania informacją, wywołały jednak chęć intensywnych zmian. Począwszy od samej nazwy, która odchodzi od zagadnień programowania na rzecz integracji informacji i systemów BI (wszak mamy mówić o Bezmiarze Informacji).

Co więcej wpisy techniczne nie będą już miały tutaj wyłączności. Zobaczymy czy zmiany wyjdą na dobre. W każdym razie trzymajcie kciuki.

Software Developer's Journal 12/2008 - moje wrażenia

2008-11-28T08:16:00.002+01:00

Nie sądziłem, iż po tak długi(e)j przerwie przyjdzie mi napisać kilka gorzkich słów na temat wydawnictwa, którego broniłem w komentarzach do artykułu na blogu Jacka Laskowskiego (patrz: Wrażenia po NetBeans Day 2008 w Gdańsku).

Wówczas napisałem, iż powinniśmy wziąć się do roboty i przekazać własne artykuły do tegoż wydawnictwa zamiast narzekać. Siłę swojego apelu odczułem na sobie dzisiaj, gdy przyszło mi zapoznać się z najnowszym numerem - 12/2008.

Początek nie był najgorszy - wśród aktualności udało mi się wyłuskać informacje o języku wspierającym proces projektowania aplikacji - Microsoft M, nowościach w MS Visual Studio 10 i premierze dacie premiery kolejnej wersji SQL Server'a. Pozostałe aktualności były raczej mało związane z programowaniem, ale traktuję ten dział jako możliwość poszerzenia horyzontów.

Pierwszy artykuł (pomijając opis konferencji) dotyczył znanego w świecie Pythona szkieletu aplikacyjnego Django. Autor - Tomasz Kropiewnicki - w czytelny i ciekawy sposób wprowadza do opisywanej przez siebie technologii. Jedyne opisywana przez niego warstwa widoków mi przypomina raczej warstwę kontrolera, jako że jej funkcjonalność nie musi ograniczać się do generowania treści na stronie. Zaiste jednak artykuł warto przeczytać, traktując go jako odskocznie od świata Javy.

Jednak kolejne artykuły wywołały we mnie zdziwienie. Po django jesteśmy bowiem uświadamiani jak założyć macierz typu mirror (RAID 1). Pomijam sam fakt, iż większość nowych płyt głównych obsługuje RAID w trybie fake-raid (realizowany programowo na poziomie BIOSu), a osoby które nie kupują drogich płyt głównych nie inwestują również w wiele dysków. Jednak wydaje się, iż ten artykuł jest świetnym materiałem na Linux+.

Jeśli jednak pominiemy ten artykuł dalej czeka nas kolejna "niespodzianka" - 3 artykuły o grach. Rozumiem, iż nie samą pracą człowiek żyje. Sam lubię uruchomić jakąś grę od czasu do czasu, ale od informacji o tego typu oprogramowaniu nie szukam w SDJcie. Jako że i te gry są dla Linuksa to artykuły powinny znaleźć się znów w Linux+.

Na szczęście dalej mamy już powrót do programowania. I takich artykułów programiści raczej oczekują. Więc jeśli ktoś z Nas wpadnie na ciekawy pomysł - przekazujmy naszą wiedzę innym :)

DB2 w PHP (środowisko Windows)

2008-06-16T17:03:00.012+02:00

Dość często tworząc aplikacje internetowe oparte na języku PHP ograniczamy się do platformy LAMP (Linux, Apache, MySQL i PHP). Czy jednak jest to jedyne rozwiązanie dostępne na rynku i czy nie mamy żadnej alternatywy?
W ostatnich latach wielkie korporacje wydały bezpłatne alternatywy swoich serwerów baz danych. Ich licencje pozwalają na wykorzystanie zaawansowanych silników zarówno do niekomercyjnych jak i komercyjnych celów, stawiając jedynie ograniczenia na platformy sprzętowe (a dokładniej rzecz ujmując na wykorzystywane zasoby). Poniżej chciałbym skupić się na wykorzystaniu jednej z owych baz danych - IBM DB2 Express-C.

W tej części skupimy się na instalacji całego środowiska na platformie systemowej Windows, natomiast w wolnym czasie postaram się dodać informacje na temat instalacji rozszerzenia php_ibm_db2 w środowisku Linux.

Z czego będziemy korzystać:

Baza danych DB2 Express-C 9.5 - dostępna na stronie http://www.ibm.com/db2/express

Serwer Apache HTTP 2 (u mnie 2.2.9) - dostępny na stronie http://apache.org

Środowisko PHP (u mnie paczka php-5.2.6-Win32) - dostępne na stronie http://www.php.net

Rozszerzenie php_ibm_db2.dll (u mnie paczka pecl-5.2.6-Win32) - dostępne na stronie http://www.php.net

Po rozpakowaniu pliku z instalatorem serwera danych uruchamiamy program setup. Na ekranie pojawi się Setup Launchapd, w którym będziemy mogli zapoznać się z informacjami o nowej wersji, instrukcją migracji z poprzednich edycji DB2 czy wymaganiami systemowymi. Wybierając opcję Install a product możemy zainstalować nowe środowisko bazy danych. Po zaakceptowaniu licencji, wybieramy standardową opcję instalacji (Typical) i na 4 kolejnych ekranach zatwierdzamy domyślne wartości. Następnie będziemy poproszeni o podanie nazwy i hasła dla tak zwanego właściciela instancji. Warto zachować użytkownika dedykowanego - db2admin - i podać dla niego hasło zgodne z aktualną polityką bezpieczeństwa w systemie (bądź domenie).
Po udanej instalacji przy pomocy konsoli Pierwsze Kroki (First Steps) będzie możliwe stworzenie przykładowej bazy danych SAMPLE.

UWAGA Jeśli ktoś nie stworzy przykładowej bazy w tym miejscu będzie tego mógł dokonać z poziomu specjalnej powłoki systemowej (db2cmd) przy pomocy polecenia db2sampl -sql -xml

Kolejnym krokiem będzie instalacja serwera Apache i PHP. W przypadku serwera WWW ogranicza się ona do zaakceptowania standardowych opcji instalacyjnych. Następnie należy rozpakować paczkę php-5.x.x-win32 do katalogu c:\PHP, a także z paczki pecl skopiować plik php_ibm_db2.dll do katalogu c:\PHP\ext.

Czas na konfigurację całości. Tworzymy kopię pliku php.ini-dist o nazwię php.ini w katalogu c:\PHP i poddajemy ją edycji. W sekcji Paths and Directories ustawiamy wartość extension_dir na "c:\PHP\ext", w Dynamic Extensions dodajemy wpis


extension=php_ibm_db2.dll

a na końcu pliku


[IBM DB2]
ibm_db2.instance_name=DB2

gdzie DB2 jest nazwą zainstalowanej przez nas instancji.

Pozostało dołaczyć PHP do Apache. W tym celu przechodzimy do katalogu konfiguracyjnego Apache (u mnie C:\Program Files\Apache Software Foundation\Apache2.2\conf) i poddajemy edycji plik httpd.conf dodając na końcu:


# For PHP 5 do something like this:
LoadModule php5_module "c:/php/php5apache2_2.dll"
AddType application/x-httpd-php .php

# configure the path to php.ini
PHPIniDir "C:/php"

Zanim wystartujemy serwer Apache warto przygotować sobie dwa pliki w katalogu htdocs (u mnie C:\Program Files\Apache Software Foundation\Apache2.2\htdocs). Pierwszy o nazwie test.php postaci:


<?php
   phpinfo();
?>

i plik db2test.php postaci:


<?php
  $database = 'SAMPLE';
  $user = 'db2admin';
  $password = 'twoje_haslo';
  
  $conn = db2_connect($database, $user, $password);
  
  if ($conn){
    echo "Connected";
    db2_close($conn);
  }
?>

Teraz pozostało jedynie uruchomienie serwera i sprawdzenie poprawności wyświetlania stron: http://localhost/test.php i http://localhost/db2test.php. Na pierwszej z nich powinny zostać wyświetlone zainstalowane moduły php, między innymi dodany przez nas ibm_db2. Na drugiej, jak łatwo się domyślić, wyświetli się napis Connected po nawiązaniu połączenia z bazą danych SAMPLE.

Skoro mamy skonfigurowane środowisko możemy zapoznać się z listą funkcji, oferowanych przez moduł ibm_db2. Pełen spis znajdziemy na stronie http://uk2.php.net/manual/pl/ref.ibm-db2.php.

Jednak jak mawiają dobry programista to leniwy programista. Pojawia się zatem pytanie czy nie można pominąć całego procesu konfiguracji i zainstalować gotowej paczki. Rozwiązaniem jest serwer Zend Core 2 for IBM dostępny na stronie www.zend.com/en/products/core/downloads . Pozwala on na dużo prostszą instalacje środowiska zawierającego Apache HTTP 2, PHP5 (z Zend Optimizerem) i DB2 Express-C 9.

Zend Framework - obsługa baz danych

2007-04-12T11:02:00.002+02:00

Przyznam szczerze, że na Zend Framework trafiłem dzięki praktykom w IBM, gdzie przyszło mi testować hybrydowy silnik baz danych (pureXML w DB2 9). Postanowiłem pobawić się bowiem serwerem Zend Core for IBM (dość szybko przerzuciłem się na Zend Core 2) i przy jego instalacji zauważyłem ZF.
W dobie programowania obiektowego mamy szeroki wybór API, które zdeserializują nam rekord tablicy na obiekt klasy, pozwolą go zmodyfikować w łatwy sposób i dokonać ponownej serializacji. Sztandarowym przykładem jest na chwilę obecną zapewne Java Persistence API opisywana szczegółowo przez Jacka Laskowskiego, ale oczywiście takiej możliwości w Zend Framework zabraknąć nie mogło.
Postanowiłem zatem omówić ten mechanizm i zwrócić uwagę na pewną ważną moim zdaniem kwestię - unikanie deserializacji do obiektów i wykorzystanie tablic bądź tablic asocjacyjnych tam (w Javie byłoby to używanie kolekcji lub tablic typów wbudowanych), gdzie istotne jest wydajne przetwarzanie informacji.

W moim przykładzie posłużę się tabelą opisującą pęk promieni kosmicznych, podobną do tej z którą pracuję na co dzień:


CREATE TABLE cosmic_rays(
   id serial NOT NULL, -- Automatycznie generowany identyfikator
   nix_date float8, -- Unix'owy stempel czasu
   peak_particles float 8, -- Liczba zarejestrowanych cząstek
   az float4, -- Położenie źródła we współrzędnych horyzontalnych - azymut
   ze float4, -- Położenie źródła we współrzędnych horyzontalnych - odległość od zenitu
   ra float4, -- Położenie źródła we współrzędnych niebieskich - rekt ascencja
   dec float4, -- Położenie źródła we współrzędnych niebieskich - deklinacja
   l float4, -- Położenie źródła we współrzędnych galaktycznych - szerokość gal
   b float4, -- Położenie źródła we współrzędnych galaktycznych - długość gal
   CONSTRAINT id PRIMARY KEY (id)
) WITHOUT OIDS;

Jak łatwo się domyślić tabela jest przygotowana dla bazy opartej o PostgreSQL, ale nie trzeba wielu zabiegów, aby przystosować ją do innego systemu baz danych.

Struktura katalogów w projekcie

Podobnie jak w poprzednim przykładzie opartym o Zend Framework struktura będzie wyglądać w następujący sposób:

application
- controllers
  - IndexController.php
- models
  - CosmicRays.php
- views

configuration
- config.xml

library
- Zend
- Zend.php

public

.htaccess

index.php

Plik .htaccess zawiera również jedynie informacje sterujące dla modułu rewrite:


RewriteEngine on
RewriteRule .* index.php

Inicjalizacja połączenia z bazą danych

Plik config.xml będzie zawierać niezbędne do zestawienia połączenia z bazą danych informacje:


<?xml version="1.0" encoding="utf-8">
<configData>
   <db>
      <adapter>PDO_Pgsql</adapter>
      <configuration>
         <host>localhost</host>
         <port>5432</port>
         <dbname>baza</dbname>
         <username>uzytkownik</username>
         <password>*****</password>
      </configuration>
   </db>
</configData>

Możemy zatem przystąpić do konfiguracji bootstrapa w pliku index.php:


//Ustawiamy ścieżki dostępu
set_include_path('.' . PATH_SEPARATOR
               . './library' . PATH_SEPARATOR
               . './application/models/' . PATH_SEPARATOR
               . get_include_path() );

//Ładujemy klasę Zend_Loader
require_once 'Zend/Loader.php';

try{

   //Ładujemy niezbędne klasy
   Zend_Loader::loadClass('Zend_Config_Xml');
   Zend_Loader::loadClass('Zend_Db');
   Zend_Loader::loadClass('Zend_Db_Table');
   Zend_Loader::loadClass('Zend_Registry');
   Zend_Loader::loadClass('Zend_View');
   Zend_Loader::loadClass('Zend_Controller_Front');

   //Ustalamy adres bazowy
   $baseUrl = substr($_SERVER['PHP_SELF'], 0, 
                     strpos($_SERVER['PHP_SELF'], '/index.php'));

   //Ładujemy konfigurację bazy danych z pliku XML (gałąź db)
   $config = new Zend_Config_Xml('./configuration/config.xml','db');
   
   //Tworzymy połączenie dla bazy danych i czynimy je domyślnym dla modeli tabel
   $db = Zend_Db::factory($config->adapter, 
                          $config->configuration->asArray());
   Zend_Db_Table::setDefaultAdapter($db);
   
 
   //Konfigurujemy klasę widoku
   $view = new Zend_View();
   $view->baseUrl = $baseUrl;
   $view->setScriptPath('./application/views');
   //Umieszczamy ją w rejestrze
   Zend_Registry::set('view',$view);

   //Inicjalizacja głównego kontrolera
   $frontController = Zend_Controller_Front::getInstance();
   $frontController->setRouter($router);
   $frontController->setBaseUrl($baseUrl);
   $frontController->setControllerDirectory(
                               './application/controllers');
   $frontController->throwExceptions(true);
   $frontController->returnResponse(true);

   //Inicjalizacja obiektu odpowiedzi
   $response = $frontController->dispatch();
   $response->renderExceptions(true);
   $response->setHeader('Pragma', 'No-cache');
   $response->setHeader('Cache-Control', 'no-cache');
   
   //Wyświetlenie strony
   echo $response;

} catch (Exception $e){
   //Obsługa wyjątków
   die($e->getMessage());
}

Jak widać dodanie obsługi naszej bazy danych wymagało od nas 6 linijek kodu (wraz z importem plików odpowiednich bibliotek).
Obiekt Zend_Config_Xml (dziedziczący po Zend_Config) jest obiektem pozwalającym na łatwe ładowanie plików konfiguracyjnych w postaci dokumentów XML. Jego użycie jest bardzo podobne do obsługi plików XML przy pomocy SimpleXML (patrz wcześniejszy post).
Inicjalizacji połączenia dokonujemy przez statyczną metodę factory klasy Zend_Db, której podajemy typ adaptera (dla większości baz są to adaptery PDO, własne adaptery posiadają jedynie DB2, Oracle i Mysqli) oraz parametry konfiguracyjne.
Z kolei statyczną metodą setDefaultAdapter klasy Zend_Db_Table ustawiamy utworzone połączenie dla wszystkich obiektów związanych z tabelami.

Nasz pierwszy model

W pliku CosmicRays.php umieścimy nasz model dla tabeli cosmic_rays:


   Zend_Loader::loadClass('Zend_Db_Table');

   class CosmicRays extends Zend_Db_Table{
      protected function _setup(){
         //Standardowo ZF ustala nazwę tabeli jako łańcuch znaków występujący
         //po ostatnim znaku _ w nazwie klasy modelu, więc musimy ją zmienić
         $this->_name = 'cosmic_rays';
         //Możemy również ustalić nazwę klucza głównego (jeśli inna niż id)
         //oraz schemat tabeli (szczególnie ważne dla baz takich jak DB2 czy Oracle)

         //Na koniec ładujemy ustawienia klasy bazowej
         parent::_setup();
      }
   }

I to by było na tyle. Musimy tylko stworzyć obiekt klasy CosmicRays i już możemy modyfikować jej obiekty. Do dyspozycji mamy metody (wymieniłem najważniejsze):

fetchNew() - tworzy nowy pusty "rekord"

fetchRow($where, $order) - zwraca pierwszy "rekord" z wyniku spełniającego warunek $where z uporządkowaniem $order

fetchAll($where, $order) - zwraca wszystkie "rekordy"

insert($data) - wstawia "rekord" na podstawie tablicy asocjacyjnej

update($data, $where) - aktualizuje dane na podstawie tablicy asocjacyjnej

Warto zwrócić uwagę, iż metoda fetchAll zwraca nam obiekt typu Zend_Db_Table_Rowset z iteratorem dla obiektów Zend_Db_Table_Rows (dzięki temu możliwe jest przeglądanie kolekcji za pomocą pętli foreach). Metody fetchNew i fetchRow zwracają nam obiekt typu Zend_Db_Table_Row.
Każdy z obiektów Zend_Db_Table_Row udostępnia nam dane w sposób podobny do obiektów stClass. Możemy zatem modyfikować je w łatwy sposób (niedopuszczalna jest jedynie modyfikacja klucza głównego), np.


   $cr  = new CosmicRays();
   $row = $cr->fetchRow("id = 10");
   $row->ra = 0;
   $row->update();

Przytoczona powyżej metoda update() daje nam możliwość zaktualizowania obiektu. Istnieje również metoda save() pozwalająca na zapis nowego obiektu utworzonego za pomocą metody fetchNew().

Problem wydajności

Problemem na jaki natrafiłem było pobranie jedynie dwóch kolumn z całej tabeli. Oczywiście możemy stworzyć obiekt select. Jednak wymaga to umieszczenia obiektu $db w rejestrze, bądź wyłuskania go z obiektu modelu.
Oczywiście dla zapytań łączących dane z wielu tabeli jest to praktycznie jedyna metoda. Co jeśli jednak chcemy dane wyłuskać TYLKO z jednej tabeli?

Stwórzmy nową metodę w klasie modelu:


   public function fetchAllColumns($columns = null, $where = null, $order = null,
   $count = null, $offset = null){
   
      // selection tool
      $select = $this->_db->select();
   
      //Set columns
      $columns = (is_null($columns))?$this->_cols:$columns;
           
      // the FROM clause
      $select->from($this->_name, $columns);
 
      // the WHERE clause
      $where = (array) $where;
      foreach ($where as $key => $val) {
         // is $key an int?
         if (is_int($key)) {
            // $val is the full condition
            $select->where($val);
         } else {
            // $key is the condition with placeholder,
            // and $val is quoted into the condition
            $select->where($key, $val);
         }
      }
 
      // the ORDER clause
      if (!is_array($order)) {
         $order = array($order);
      }
      foreach ($order as $val) {
         $select->order($val);
      }
 
      // the LIMIT clause
      $select->limit($count, $offset);
 
      // return the results
      $stmt = $this->_db->query($select);
      $data = $stmt->fetchAll(Zend_Db::FETCH_ASSOC);
                  
      return $data;
   }

Osoby, które przyglądały się klasie Zend_Db_Table_Abstract zauważą szybko, że moja metoda nie jest niczym innym jak lekko zmodyfikowaną metodą _fetch(...).
Warto jednak spojrzeć na implementacje metody fetchAll(...) tej klasy. Otóż tablicę asocjacyjną opakowuje ona w obiekt Zend_Db_Table_Rowset. W sytuacjach kiedy zależy nam na wydajności oraz niskim zapotrzebowaniu na pamięć warto zrezygnować z ułatwienia jakie niesie za sobą klasa Zend_Db_Table_Rowset.

Na koniec jeszcze jedna rada. Warto korzystać z instrukcji unset($data), szczególnie jeśli obiekt $data jest pokaźnych rozmiarów tablicą, której dalej nie zamierzamy używać. Tymbardziej, że często administratorzy serwerów nie dają dla skryptów php więcej niż 16MB pamięci.

Przetwarzanie XML w językach Java i PHP (cz.2)

2007-04-04T19:27:00.000+02:00

W przypadku PHP dostępność standardów obsługi XMLa ewoluowała wraz z kolejnymi wersjami. Dla wersji 3 dostępny był interfejs SAX, który nie zmienił się do chwili obecnej (problemy kompatybilności mogą być związane jedynie z obsługą przestrzeni nazw dla elementów, jeżeli zainstalowana jest biblioteka libxml2 w wersji starszej niż 2.6).

W wersji 4 dodano obsługę DOM (rozszerzenie domxml) oraz XSLT (rozszerzenie xslt). Pierwsze z nich nie spełniało jednak założeń W3C, powodowało wiele wycieków pamięci, przez co nie było zbyt popularne. Drugie wymagało do działania biblioteki Sablotron lub Expat.

Prawdziwy przełom przyniosła wersja 5. Obsługa DOM została przepisana na nowo, zgodnie ze standardami W3C i umieszczona w rozszerzeniu DOM. Dodano obsługę XPath oraz walidację według plików DTD (odnośnik umieszczony w pliku XML), XSchema oraz RelaxNG (nazwa pliku definiowana w wywołaniu funkcji).
XSLT zostało oparte o bibliotekę libxslt (najszybsze rozwiązanie na rynku) i umieszczone w rozszerzeniu XSL.
Oba nabrały również prawdziwie obiektowego charakteru.
Co więcej dodano interfejs SimpleXML umożliwiający łatwą modyfikacje plików XML bez znacznego obciążenia systemu charakterystycznego dla DOM.

SAX

Parser SAX tworzymy poprzez wywołanie funkcji xml_parser_create(); Kolejnym etapem jest utworzenie funkcji odpowiadających zdarzeniom XML i ich zarejestrowanie. Pod adresem http://pl.php.net/manual/en/ref.xml.php#id7330424 dostępny jest przykład takiego parsera (łącznie ze sprawdzaniem zewnętrznych encji).

DOM i SimpleXML

W przypadku PHP 5 użycie DOM jest analogiczne jak w innych językach programowania (JavaScript, Java...). Pracę z nim rozpoczynamy od utworzenia obiektu DOMDocument.
SimpleXML jest natomiast bardzo ciekawym intefejsem. Na podstawie pliku XML tworzy on coś na kształt klasy PHP stdClass (dla innych języków obiektowych można porównać to do klasy będącej kolekcją obiektów). Dzięki czemu do danego elementu odwołujemy się w bardzo przyjemny sposób (Zend wykorzystał ten intefejs przy tworzeniu klasy Zend_Config_XML).
Warto zauważyć, że poprzez funkcję simplexml_import_dom i dom_import_simplexml możemy łatwo konwertować dane z jednego standardu na drugi (jest to szczególnie przydatne w przypadku zapisywania dokumentu XML do pliku, której to SimpleXML funkcji nie posiada).

Przykład

Na koniec chciałbym przedstawić przykład, który pobiera dane z tabeli Customers (baza Sample XML dla IBM DB2 9) i wyciąga z nich imię i nazwisko klienta. Pragnę zwrócić uwagę na dwa elementy. Po pierwsze różnice w objętości dla SimpleXML i DOM realizujących tą samą operację. Po drugie warto zauważyć, iż metody klas DOMDocument w PHP i Document dla Javy są takie same:


   error_reporting(E_ALL|E_STRICT);
   
   $user = "db2admin";
   $password = "***";
   $database = "SAMPLE";
   $hostname = "localhost";
   $port = 50000;
 
   $connect_string = "DRIVER={IBM DB2 ODBC DRIVER};" .
                     "DATABASE=$database;" .
                     "HOSTNAME=$hostname;" .
                     "PORT=$port;" .
                     "PROTOCOL=TCPIP;" .
                     "UID=$user;" .
                     "PWD=$password;";
   $connection = db2_connect($connect_string,'','');
   if ($connection){
      echo "Connection successful.<br />";
      $sql = "SELECT INFO FROM CUSTOMER WHERE CID = ?";
      $statement = db2_prepare($connection, $sql);
      db2_execute($statement,array(1001));
  
      while ($customer = db2_fetch_object($statement)){
         $info = $customer->INFO;
      
         //SimpleXML
         $simpleXML = new SimpleXMLElement($info);
         echo $simpleXML->name."<br />";

         //DOM
         $domDocument = new DOMDocument('1.0','UTF-8');
         $domDocument->loadXML($info);
         $names = $domDocument->getElementsByTagName('name');
         foreach ($names as $name) {
            echo $name->nodeValue.'<br />';
         }
      }
      db2_close($connection);
   }else{
      echo "Connection failed.";
   }

Podsumowanie

Pokazane w obu częściach przykłady stanowią jedynie czubek góry lodowej związanej z przetwarzaniem dokumentów XML w językach Java i PHP. Jednak mogę okazać się przydatnym wstępem do dalszego zgłębiania tematu.

Wszelakie komentarze i uwagi mile widziane

Przetwarzanie XML w językach Java i PHP (cz.1)

2007-04-04T15:04:00.000+02:00

Realizując praktyki z bazą IBM DB2 9 (w szczególności jej hybrydowym silnikiem) napotkałem na brak informacji na temat przetwarzania danych XML dostępnych w postaci strumieni.

Podczas lektury książki J2EE. Vademecum Programisty doszedłem nawet do błędnego wniosku jakoby przed wersją 1.6 Javy nie była taka obsługa zaimplementowana w standardzie. Wszędzie były tylko informacje jak parsować pliki XML.

Po przeszukaniu internetu natrafiłem na STreaming Api for XML (StAX) i jego dokumentacje w postaci JSR-173. Okazało się, że Java SE 1.6 zawiera nawet interfejs do niego, jednak brak jest implementacji. Na stronie http://stax.codehaus.org/ szybko tą implementację znalazłem, a później natrafiłem jeszcze na implementację Sun'a (pod adresem https://sjsxp.dev.java.net/) oraz Bea Weblogic (pod adresem http://dev2dev.bea.com/xml/stax.html). Ponieważ pierwsza z tych trzech stanowi implementację referencyjną będzie użyta w niniejszym tutorialu.

Niezależnie od wszystkiego postanowiłem jeszcze raz sprawdzić możliwości analizy strumieni tekstowych z XMLem dla standardów Simple Api for XML (SAX) i Document Object Model (DOM). Okazało się, że tkwiłem w błędnym przekonaniu.

SAX

SAX jest uznawany za najszybszy i najmniej pamięciożerny parser XML. Opiera się o reprezentację zdarzeniową, w której otwarcie i zamknięcie każdego dokumentu, znacznika czy występowanie tekstu jest określane jako zdarzenie.

Niewątpliwą wadą SAXa jest brak wiedzy o położeniu w pliku XML (stanu). Jest to również dość ciężki do implementacji we własnych projektach interfejs.

Pracę z SAXem rozpoczynamy od stworzenia klasy reagującej na zdarzenia (u mnie MyHandler). Poniższy przykład opiera się na kodzie zawartym w książce J2EE. Vademecum Programisty dostępnej w sprzedaży wydawnictwa Helion:


package org.f2k.test;


import java.io.IOException;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class MyHandler extends DefaultHandler {
   StringBuffer textBuffer;
   static private Writer  out;
   
   public MyHandler() throws UnsupportedEncodingException{
      out = new OutputStreamWriter(System.out, "UTF8");
   }

   public void startDocument() throws SAXException{
      nl();
      nl();
      emit("START OF DOCUMENT");
      nl();
      emit("");
   }

   public void endDocument() throws SAXException{
      nl(); 
      emit("END OF DOCUMENT");
      try {
         nl();
         out.flush();
      } catch (IOException e) {
         throw new SAXException("IO Exception", e);
      }
   }
   
   public void startElement(String namespaceURI,
   String sName, // nazwa skrócona
   String qName, // nazwa pełna
   Attributes attrs) throws SAXException{
        
      echoText();
      nl(); 
      emit("ELEMENT: ");
      String eName = sName; // nazwa elementu
      // bez uwzględnienia nazwy przestrzeni nazw
      if ("".equals(eName)) 
         eName = qName; 
      emit("<"+eName);
      if (attrs != null) {
         for (int i = 0; i < attrs.getLength(); i++) {
            String aName = attrs.getLocalName(i); // nazwa atrybutu
            if ("".equals(aName)) aName = attrs.getQName(i);
            nl();
            emit("   ATR: ");
            emit(aName);
            emit("\t\"");
            emit(attrs.getValue(i));
            emit("\"");
         }
      }
      if (attrs.getLength() > 0) nl();
      emit(">");
   }

   public void endElement(String namespaceURI,
   String sName, // nazwa skrócona
   String qName  // nazwa pełna
   )throws SAXException {
      echoText();
      nl();
      emit("END_OF_ELEM: ");
      String eName = sName; // nazwa elementu
      if ("".equals(eName)) 
         eName = qName;
      emit("");
   }

   public void characters(char buf[], int offset, int len)
   throws SAXException{
      String s = new String(buf, offset, len);
      if (textBuffer == null) {
         textBuffer = new StringBuffer(s);
      } else {
         textBuffer.append(s);
      }
   }
    

   // Metody pomocnicze
   private void echoText() throws SAXException{
      if (textBuffer == null) return;      
      nl(); 
      emit("CHARS: |");
      String s = ""+textBuffer;
      emit(s);
      emit("|");
      textBuffer = null;
   }

   private void emit(String s) throws SAXException{
      try {
         out.write(s);
         out.flush();
      } catch (IOException e) {
         throw new SAXException("IO Exception", e);
      }
   }

   private void nl() throws SAXException{
      String lineEnd =  System.getProperty("line.separator");
      try {
         out.write(lineEnd);
      } catch (IOException e) {
         throw new SAXException("IO Exception", e);
      }
   }
}

Skoro mamy już klasę obsługującą zdarzenia przygotujmy klasę testową, dzięki której będziemy mogli podać String zawierający XML:


package org.f2k.test;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.helpers.DefaultHandler;

public class SAXTest {
   SAXTest(String xml){
      this(new ByteArrayInputStream(xml.getBytes()));
   }
 
   SAXTest(InputStream stream){
      try {
         DefaultHandler handler = new MyHandler();
         SAXParserFactory factory = SAXParserFactory.newInstance();
         SAXParser parser = factory.newSAXParser();
         parser.parse(stream, handler);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Mamy właściwie wszystko co potrzeba dla SAX. Możemy jeszcze dla obiektu factory ustawić opcję sprawdzania dokumentu XML według DTD, itp. Ale to pozostawiam już programistom:)

DOM

DOM jest parserem, który wykorzystuje się do złożonych modyfikacji XML, czy jego reprezentacji w postaci drzewa obiektu. Jego wadą jest fakt, że jest zasobożerny. Cały dokument jest bowiem przetwarzany w pamięci komputera.

W przypadku DOM możemy od razu napisać naszą klasę testową:


package org.f2k.test;

import java.io.ByteArrayInputStream;
import java.io.InputStream;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;

public class DOMTest {
   public DOMTest(String xml){
      this(new ByteArrayInputStream(xml.getBytes()));
   }

   public DOMTest(InputStream stream){
      try {
         DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
         DocumentBuilder builder = factory.newDocumentBuilder();
         Document document = builder.parse(stream);
         NodeList names = document.getElementsByTagName("name");
         for(int i=0; i < names.getLength(); i++){
            System.out.println(names.item(i).getTextContent());
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Nasz test wyszukuje w dokumencie XML węzły o nazwie name i wyświetla ich zawartość.

StAX

StAX jest pareserem opracowanym przez firmę BEA. Choć jego działanie opiera się na zdarzeniowej formie XML, to udostępnia nam wiedzę o położeniu w dokumencie poprzez iterator. Pozwala to na szybszą niż w przypadku DOM deserializację prostych obiektów.

Najprostszym użyciem StAXa jest stworzenie funkcji, która będzie analizować zdarzenia. W poniższym przykładzie funkcja processEvent będzie realizować podobne zadanie do klasy MyHandler z testu SAX:


package org.f2k.test;

import java.io.*;
import javax.xml.stream.*;
import javax.xml.stream.events.*;


public class StAXTest {
   StringBuffer textBuffer;
   static private Writer out;

   StAXTest(String xml){
      this(new ByteArrayInputStream(xml.getBytes()));
   }
 
   StAXTest(InputStream stream){
     try {
        out = new OutputStreamWriter(System.out, "UTF8");
     } catch (UnsupportedEncodingException e1) {
        e1.printStackTrace();
     }
     /*Implementation of StAX*/
     System.setProperty("javax.xml.stream.XMLInputFactory",
     "com.bea.xml.stream.MXParserFactory"); 

     try {
        XMLInputFactory inputFactory 
            = XMLInputFactory.newInstance();
 XMLEventReader eventReader 
            = inputFactory.createXMLEventReader(stream);
        while (eventReader.hasNext()){
           XMLEvent event = (XMLEvent) eventReader.next();
           processEvent(event);
        }
     } catch (Exception e) {
       e.printStackTrace();
     }
   }
   
   public void processEvent(XMLEvent event) throws IOException{
      if (event.isStartElement()){
         echoText();
         nl(); 
         emit("ELEMENT: <");
         emit(((StartElement) event).getName().toString());
         emit(">");
      }
      if (event.isCharacters()){
         String s = ((Characters) event).getData();
         if (textBuffer==null){
            textBuffer = new StringBuffer(s);
         } else {
            textBuffer.append(s);
         }
      }
      if (event.isEndElement()){
         echoText();
         nl();
         emit("END_OF_ELEM: ";
         emit("");
      }
   }
 
   // Metody pomocnicze
   private void echoText() throws IOException{
      if (textBuffer == null) return;      
      nl(); 
      emit("CHARS: |");
      String s = ""+textBuffer;
      emit(s);
      emit("|");
      textBuffer = null;
   }
   private void emit(String s) throws IOException{
      out.write(s);
      out.flush();
   }
   private void nl() throws IOException{
      String lineEnd =  System.getProperty("line.separator");
      out.write(lineEnd);
   }
}

Skoro mamy już wszystkie testy pora sprawdzić działanie każdego z parsera. Do tego celu wykorzystałem tabelę Customer z bazy SAMPLE (w wersji XML) dostępnej z DB2 9. Poniżej kod zestawiający połączenie i pobierający rekord:


package org.f2k.test;

import java.io.InputStream;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import com.ibm.db2.jcc.DB2Xml;

public class DB2Connector {
   String password="***";
   String user="db2admin";

   String url = "jdbc:db2://localhost:50000/SAMPLE";
   public DB2Connector(){
      try {
         Class.forName("com.ibm.db2.jcc.DB2Driver").newInstance();
         Connection conn = DriverManager.getConnection(url, 
                                             user, password);
         PreparedStatement stmt  = conn.prepareStatement(
                "SELECT INFO FROM MCUSTOMER WHERE CID = ?");
         //Należy wcześniej sprawdzić czy użytkownik o CID 1001 istnieje
         stmt.setInt(1, 1001);
         ResultSet result = stmt.executeQuery();
         while (result.next()){
            DB2Xml info = (DB2Xml) result.getObject("INFO");
            String xmlText = info.getDB2XmlString();
     System.out.print("DB2XmlString:\n"+xmlText);
            //Dla kodowania innego niż UTF-8 tylko StAX przechodzi test
            InputStream stream = info.getDB2XmlBinaryStream("UTF-8");
            System.out.println("\n");
            System.out.println("DB2Xml from StAX test:");
            new StAXTest(stream);
            System.out.println("\n");
            System.out.println("DB2Xml from SAX test:");
            stream.reset();
            new SAXTest(stream);
            System.out.println("\n");
            System.out.println("DB2Xml from DOM test:");
            stream.reset();
            new DOMTest(stream);
         }
         result.close();
         conn.close();
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
   
   public static void main(String[] args){
      new DB2Connector();
   }
}

Wyniki

Parsery StAX i SAX powinny zwrócić w wyniku poszatkowaną strukturę XML z opisami zdarzeń. Natomiast DOM powinien wyświetlić imię i nazwisko klienta, wyciągnięte z XMLa (u mnie Kathy Smith).

W drugiej części opiszę systemy przetwarzania XML z PHP. Również na podstawie danych zaczerpniętych z DB2.

Zend_Controller_Router_Route i tworzenie nowych tras (dla wersji 0.9 i nowszych)

2007-04-04T11:49:00.000+02:00

Jak słusznie zauważył Wojciech w komentarzu do poprzedniego postu od wersji 0.9 wprowadzono kilka zmian. Między innymi w celu umieszczenia biblioteki w jednym katalogu postanowiono podzielić klasę Zend na kilka innych. Plik Zend.php zapewnie zniknie w wersji 1.0.

Jako, że ja w swoim projekcie opierałem się o wersję 0.8 postanowiłem podać zmodyfikowaną wersję kodu, a właściwie jedynie fragmentu pliku index.php:


 //Od tej pory zamiast pliku Zend.php ładujemy klasę loadera

 require_once 'Zend/Loader.php';


 try {

    //Ładowanie klas odbywa się poprzez metodę klasy

    //Zend_Loader

    //Dodatkowo wymagana jest klasa obsługi rejestu

    Zend_Loader::loadClass('Zend_Registry');

    Zend_Loader::loadClass('Zend_View');

    Zend_Loader::loadClass('Zend_Controller_Front');

    Zend_Loader::loadClass('Zend_Controller_Router_Rewrite');

    //Ustalamy adres bazowy
    $baseUrl = substr($_SERVER['PHP_SELF'], 0,

                     strpos($_SERVER['PHP_SELF'], '/index.php'));
  
    //Konfigurujemy klasę widoku
    $view = new Zend_View();
    $view->baseUrl = $baseUrl;
    $view->setScriptPath('./application/views');
    //Umieszczamy ją w rejestrze poprzez metodę nowej klasy
    Zend_Registry::set('view',$view);

Reszta kodu pozostaje bez zmian

Zend_Controller_Router_Route i tworzenie nowych tras

2007-04-03T17:42:00.000+02:00

Ostatnio na polskim forum Zend Framework spotkałem się z problemem obsługi przyjaznych adresów. Standardowo biblioteka ta obsługuje adresy w postaci:

http://nazwa_strony/nazwa_kontrolera/nazwa_akcji/parametr/wartość

Jednak strona miała zawierać treść wielojęzyczną. I choć Zend obsługuje możliwość odczytania informacji z przeglądarki to programista chciał sterować językiem poprzez umieszczenie kodu przed nazwą kontrolera, np.:

http://nazwa_strony/pl/nazwa_kontrolera/...

Postanowiłem zatem zajrzeć do dokumentacji i napisać niezbędny kod. Zaczniemy od struktury katalogów, którą zaczerpnąłem z jednego tutoriala:

application

controllers

IndexController.php

models
views

library

Zend
Zend.php

public
.htaccess
index.php

Plik .htaccess zawiera informacje sterujące dla modułu rewrite:

RewriteEngine on
RewriteRule .* index.php

Plik index.php stanowi tak zwany bootstrap dla ZF. W nim dokonujemy należy zainicjalizować wszystkie niezbędne do działania elementy środowiska. A więc do dzieła:


   //Konfiguracja debugowania

   define('_DEBUG',1);
 
   

   if (defined('_DEBUG'))

      if (_DEBUG == 1)
 
         error_reporting(E_ALL|E_STRICT);

   

   date_default_timezone_set('Europe/Warsaw');

   

   //Konfigurujemy ścieżki bibliotek

   set_include_path('.' . PATH_SEPARATOR

                    . './library' . PATH_SEPARATOR

             . './application/models/' . PATH_SEPARATOR

             . get_include_path() );

   

   //Ładujemy jądro ZF

   include('Zend.php');

   

   try {

      //Ładujemy niezbędne klasy

      Zend::loadClass('Zend_View');

      Zend::loadClass('Zend_Controller_Front');

      Zend::loadClass('Zend_Controller_Router_Rewrite');

      
 
      //Ustawiamy adres bazowy

      $baseUrl = substr($_SERVER['PHP_SELF'], 0, 

                        strpos($_SERVER['PHP_SELF'], '/index.php'));

      

      //Konfiguracja klasy widoku
      $view = new Zend_View();

      $view->baseUrl = $baseUrl;

      $view->setScriptPath('./application/views');

      Zend::register('view',$view);

      

      //Tutaj konfigurujemy naszą nową trasę

      $route = new Zend_Controller_Router_Route(

      ':lang/:controller/:action',
 
      //Zmienna określająca język znajduje się przed kontrolerem

      array('lang'=>'pl', 'controller'=>'index',
 
      'action'=>'index'), //Wartości domyślne

      array('lang'=>'[a-z_]+')); //Warunek dla lang

      
 
      //Utworzenie routera z naszą trasą

      $router = new Zend_Controller_Router_Rewrite(); 

      $router->removeDefaultRoutes();

      $router->addRoute('user', $route);

      

      //Inicjalizacja głównego kontrolera

      $frontController = Zend_Controller_Front::getInstance();

      $frontController->setRouter($router);

      $frontController->setBaseUrl($baseUrl);

      $frontController->setControllerDirectory(

                        './application/controllers');

      $frontController->throwExceptions(true);

      $frontController->returnResponse(true);

      

      //Inicjalizacja obiektu odpowiedzi

      $response = $frontController->dispatch();

      $response->renderExceptions(true);

      $response->setHeader('Pragma', 'No-cache');

      $response->setHeader('Cache-Control', 'no-cache');

      

      //Wyświetlenie strony

      echo $response;

   } catch (Exception $exception) {

      //Obsługa wyjątku

      $message = 'Application setup exception: ';

      $message.= $exception->getMessage();

      if (defined('_DEBUG')) if (_DEBUG){

         $message .= 'Trace: '.$exception->getTraceAsString();

      }

      die($message);

   }

Nie pozostało zatem nic innego jak odczytać informacje o języku. Dokonamy tego w pliku IndexController.php:


class IndexController extends Zend_Controller_Action

{

   function indexAction()

   {

      echo $this->_getParam('lang','pl');

      echo " in IndexController::indexAction()";

   }

}

Po przekopiowaniu plików na serwer dostaniemy informacje o języku i wywołanej metodzie

Powitanie

2007-04-03T17:34:00.000+02:00

Na wstępie nie wypada mi nie przywitać wszystkich osób, które pojawiły się na moim blogu. Powstał on właściwie pod wpływem Jacka Laskowskiego, który w przejrzysty sposób dzieli się swoimi doświadczeniami z zakresu J2EE.
Co prawda nie mogę porównać swojej wiedzy do zakresu wiadomości Jacka. Jednak postanowiłem dzielić się swoimi doświadczeniami z programowaniem. Często zdarzało mi się bowiem dotykać technologii, które nie były popularne na rynku polskim i ciężko było znaleźć dokładny opis ich działania.
Zapraszam zatem do czytania i komentowania moich nowych postów.