Problem

Czasami udaje się nam doprowadzić swoją niemałą bazę danych do takiego stanu, w którym część sekwencji będzie źle ustawiona, a tym samym nie będzie możliwe dodawanie nowych danych w standardowy sposób, gdyż kolejnym id wg sekwencji, będzie takie, które już w bazie istnieje.

Możemy wtedy ręcznie naprawić daną sekwencję, zgodnie z manualem:

ALTER SEQUENCE serial RESTART WITH 105;

Gdzie serial to nazwa sekwencji. Co jednak, gdy mamy kilkaset popsutych tabelek?

Rozwiązanie — teoria

Na szczęście PostgreSQL udostępnia nam duuużo informacji o każdej swojej bazie danych w schemie information_schema, która to zawiera zestaw zawsze dostępnych widoków. My tutaj wykorzystamy dwa:

• columns — informacje o wszystkich kolumnach i widokach w bazie
• constraint_column_usage — informacje o kolumnach, które są obłożone jakimś constraintem

To co chcemy zrobić to:

1. Znaleźć wszystkie zestawy tabela-kolumna-sekwencja (bazując na tym, że definicja sekwencji jest stała, zawiera wywołanie nextval().
2. Dla każdej kolumny znaleźć największą wartość identyfikatora.
3. Zrestartować każdą sekwencję z wartością znalezioną w poprzednim kroku i zwiększoną o 1.

Rozwiązanie — praktyka

W praktyce wystarczy wykonać poniższy kod w swojej bazie danych. Tworzy on funkcję naprawiającą sekwencje, wykonuje ją raz i a następnie ją kasuje. Należy pamiętać, że działanie jest ograniczone do schemy public. Jeśli chcemy naprawić inną, trzeba sobie kod lekko zmodyfikować (np. dodając nazwę schemy jako paramert).

CREATE OR REPLACE FUNCTION rebuild_sequences() RETURNS INTEGER AS
$body$
DECLARE
	sequencedefs RECORD;
	c INTEGER;
BEGIN
	-- Find sequence name and primary key column for every table
	FOR sequencedefs IN
	SELECT DISTINCT
		constraint_column_usage.TABLE_NAME AS TABLE_NAME,
		constraint_column_usage.column_name AS column_name,
		REPLACE(REPLACE(COLUMNS.column_default,'''::regclass)',''),'nextval(''','') AS sequence_name
		FROM
			information_schema.constraint_column_usage, information_schema.COLUMNS
		WHERE
			constraint_column_usage.table_schema = 'public' AND 
			COLUMNS.table_schema = 'public' AND
			COLUMNS.TABLE_NAME = constraint_column_usage.TABLE_NAME AND
			constraint_column_usage.column_name = COLUMNS.column_name AND
			COLUMNS.column_default IS NOT NULL AND
			COLUMNS.column_default LIKE ('nextval%')
	LOOP
		-- Find current max PK value
		EXECUTE 'SELECT max('||sequencedefs.column_name||') FROM ' || sequencedefs.TABLE_NAME INTO c;
 
		IF c IS NULL THEN
			c = 1;
		ELSE
			c = c + 1;
		END IF;
 
		-- Rebuild sequence
		EXECUTE 'ALTER SEQUENCE ' || sequencedefs.sequence_name ||' RESTART WITH ' || c;
	END LOOP;
 
	RETURN 1;
END;
$body$ LANGUAGE plpgsql;
 
SELECT rebuild_sequences();
 
DROP FUNCTION rebuild_sequences();

Pierwsza wersja funkcji została napisana przez Klausa ze StackOverflow. Wersja powyżej zawiera poprawki błędów, niedociągnięć oraz formatowania.

Podobne wpisy:

1. Logowanie do pliku wszystkich zapytań w PostgreSQL
2. Migracja MySQL → PostgreSQL aplikacji w Symfony 1.1
3. PostgreSQL: obliczanie odstępów czasu

Wycofywanie zmian w Subversion można podzielić na dwie kategorie. Pierwsza to wycofywanie zmian lokalnych, jeszcze przed wysłaniem do repozytorium. Druga to odwracanie zmian już zatwierdzonych.

Wycofywanie lokalne

Anulowanie zmian w kopii lokalnej jest w miarę proste i intuicyjne. Wykorzystujemy tutaj podpolecenie revert, po którym podajemy nazwę pliku lub maskę. Opcją którą właściwie trzeba znać jest -R, która włącza wycofywanie rekursywne. Przykłady:

Anulowanie zmian w pliku ‘playground’:

svn revert playground

Anulowanie wszystkich zmian w projekcie (uruchamiane w głównego katalogu):

svn revert -R *

Wycofywanie zmian z repozytorium

W Subversion de facto nie da się wycofać zmiany już zatwierdzonej. Zamiast tego można jednak zatwierdzić zmiany odwrotne do wprowadzonych. Efekt będzie taki jak zamierzony, jednak „wadliwe” zmiany zostaną w historii. Dlatego konieczne jest tutaj użycie podpolecenia merge a nie revert, które, patrząc na nazwę, wydawało by się bardziej intuicyjne.

Zakres zmian do wycofania możemy podać używając dwóch przełączników:

-c Podajemy nr jednego zatwierdzenia, który może być ujemy. Podanie -c 123 jest równoważne z -r 122:123, natomiast -c -64 to to samo co -r 65:64

-r Podajemy zakres zatwierdzeń. Przykładowo -r 100:120.

Podając malejący zakres rewizji lub nr poprzedzony minusem otrzymujemy zmian odwrotne do wprowadzonych, co można sobie fajnie sprawdzić używając podpolecenia diff:

svn diff -r 56:57 testfile 
Index: testfile
===================================================================
--- testfile    (revision 56)
+++ testfile    (revision 57)
@@ -1 +1,3 @@
 Treść początkowa
+
+Wprowadzenie treści błędnej

svn diff -c -57 testfile
Index: testfile
===================================================================
--- testfile    (revision 57)
+++ testfile    (revision 56)
@@ -1,3 +1 @@
 Treść początkowa
-
-Wprowadzenie treści błędnej

Powyższe przykłady prezentują jak podejrzeć wprowadzoną zmianę oraz jak otrzymać patch do jej wycofania. Samo wycofanie polega na scaleniu zmian odwrotnych oraz zatwierdzeniu tej zmiany:

> svn merge -c -57 testfile
--- Reverse-merging r57 into 'testfile':
U    testfile
 
> svn diff testfile 
Index: testfile
===================================================================
--- testfile    (revision 57)
+++ testfile    (working copy)
@@ -1,3 +1 @@
 Treść początkowa
-
-Wprowadzenie treści błędnej
 
> svn ci

Podobne wpisy:

1. Naj- opisy zmian w kodzie

Jak statyczne zmienne działają?

Wielu z nas jest przyzwyczajonych do tego, że elementy oznaczone jako statyczne to coś co występuje tylko w klasach. Jednak słówka static można również użyć w zwykłej funkcji do oznaczenia zmiennej. Czym się różni zwykła zmienna od statycznej?

Wartość statycznej zmiennej jest inicjowana za pierwszym wywołaniem funkcji i zapamiętywana pomiędzy jej kolejnymi wywołaniami. Czyli zachowuje się zupełnie podobnie do klasowych zmiennych statycznych, tyle że nie za bardzo jest do niej dostęp z zewnątrz.

Gdzie to się może przydać?

1. Licznik wywołań funkcji.

Sztandarowym przykładem wykorzystania statycznych zmiennych w funkcji jest licznik jej wywołań, raczej rzadko wykorzystywany w praktyce.

function say_hello_and_count_yourself()
{
    static $counter = 0;
    echo "Hello! I've already said this ".$counter++." time(s).";
}

2. Licznik elementów na stronicowanej liście

Tu już przykład z życia wzięty. Mamy do wyświetlenia listę elementów podzieloną na strony i chcemy wyświetlić liczby porządkowe przy każdym z nich. Do funkcji jako parametr podajemy nr strony i za każdym jej wywołaniem dostajemy liczbę większą o jeden (oczywiście z uwzględnieniem strony na której aktualnie jesteśmy):

function calculate_order_num ($page = 1)
{
	static $i = 0;
 
	return (PER_PAGE * ($page - 1) + ++$i);
}

3. Odróżnianie parzystych i nieparzystych wierzy

Dość często zachodzi potrzeba pokolorowowania co drugiego wiersza w tabeli w inny sposób. Wykorzystując statyczne zmienne, możemy sobie napisać zwięzłą i możliwą do wykorzynia wiele razy funkcję:

function calculate_parity ($word1 = 'odd', $word2 = 'even')
{
	static $current = false;
	$current = !$current;
 
	return ($current ? $word1 : $word2);
}

Wywołując tę funkcję wiele razy będziemy otrzymywać podane wartości naprzemiennie. Przykładowo:

<tr class="<?= calculate_parity() ?>">…
<tr class="<?= calculate_parity() ?>">…
<tr class="<?= calculate_parity() ?>">…

Da nam:

<tr class="odd">…
<tr class="even">…
<tr class="odd">…

Prędkość działania

Miałem podejrzenia, że przechowywanie wartości w zmiennej statycznej może działać nieco szybciej niż w standardowy sposób jednak okazało się inaczej, przynajmniej w jednym prostym teście. Na (pozbawionym sensu) przykładzie sumowania kolejnych liczb:

1) Sumę trzymamy w „globalu” a funkcja do aktualnej sumy dodaje składnik:

function sum_up ($sum, $addend)
{
	return $sum + $addend;
}
 
$sum = 0;
for ($i = 1; $i <= 40000000; $i++)
{
	$sum = sum_up ($sum, $i);
}
 
echo "$sum\n";

Średni czas wykonania: 13-14s.

2) Sumę inicjujemy w funkcji i tam ją trzymamy:

function sum_up ($addend)
{
	static $sum = 0;
	return $sum += $addend;
}
 
for ($i = 1; $i <= 40000000; $i++)
{
	$s = sum_up ($i);
}
 
echo "$s\n";

Średni czas wykonania: 15-16s.

Także jak widać, ze zmiennymi statycznym jest wolniej. Do tego, pierwszy przykład można zoptymalizować, przekazując zmienną przez referencję, ale tego już nie robiłem, żeby zachować odzwierciedlenie działania możliwie dobrze (i mam nadzieje, że nic nie pomieszałem).

Podsumowanie

Podsumowując: bardzo wielu zastosowań dla zmiennych statycznych w funkcji nie widać, jednak w kilku przypadkach mogą one nam całkiem fajnie skrócić i uprościć kod. Jednocześnie trzeba się liczyć z tym, że ich wykorzystanie może nie być najszybszym rozwiązaniem, jednak są to różnice, które dla 99.9% projektów są raczej pomijalne.

Podobne wpisy:

1. Co lepiej wiedzieć o JavaScriptcie cz.2.: hoisting, deklaracje funkcji i wyrażenia funkcyjne
2. PHP: Sortowanie obiektów po dacie utworzenia
3. PHP: prawie jak parametry nazwane

Vim pozwala na łatwe zwiększanie lub zmniejszanie liczb, które mamy w trybie edycji pod kursorem poprzez skróty CTRL-A (zwiększanie) i CTRL-X (zmniejszanie).

Kiedy i jak to działa?

Vim może operować na 4 zestawach znaków:

• liczby dziesiętne,
• liczby ósemkowe,
• liczby szesnastkowe,
• litery.

Liczby ósemkowe Vim rozpoznaje po zerach początkowych. Przykładowo: 01 jest zwiększane do 02, 007 do 010. Liczy szesnastkowe Vim rozpozna, jeśli zaczynają się od 0x lub 0X — tym samym zwiększenie wygląda przykładowo tak: 0xff → 0x100. Pozostałe liczby traktowane są jako dziesiętne, a operacje na nich są dość intuicyjne.

Ponadto Vim może zwiększać pojedyncze litery: 'a' zostanie zwiększone do 'b', jednak próbując zwiększyć 'aa' zmieni się tylko litera pod kursorem, a nie całe słowo.

Przejmujemy kontrolę

Za pomocą opcji :set nrformats (skrót nf) możemy wyłączyć lub włączyć rozpoznawanie liter, liczb ósemkowych i szesnastkowych. Dostępne opcje to:

• alpha,
• octal,
• hex.

Liczby dziesiętne zawsze są rozpoznawane.

Moje ustawienie w .vimrc to:
set nrformats=alpha,hex
Różni się ono od domyślnego przede wszystkim wyłączeniem zwiększania ósemkowego, gdyż dużo częściej operuję na słowach typu 006, 007, 008 niż liczbach ósemkowych. Inaczej mówiąc zmieniam z 007 na 008, a nie na 010.

Uwagi

• Skróty CTRL-A, CTRL-X mogą operować na ujemnych liczbach dziesiętnych.
• Możliwe jest wielokrotne zwiększenie, przez podanie liczby wykonań zaraz przez skrótem. Przykładowo mając pod kursorem cyfrę 0x01 i wklepując 17<CTRL-A> otrzymamy 0x12.

Podobne wpisy:

1. Vim: dopełnianie dowolnego tekstu (np. słów kluczowych PHP)
2. Krótko: Vim i powolna edycja plików PHP

Mając utworzony projekt Symfony (1.4) mamy dostęp do zadań (tasków), którymi możemy wygenerować aplikację i moduł:

./symfony generate:app nazwa_aplikacji
./symfony generate:module nazwa_aplikacji nazwa_modułu

O ile aplikacji zwykle jest jedna albo dwie, to modułów może być w danym projekcie całkiem sporo. Więc, jeżeli nie zadowala Cię domyślny wygląd modułu, warto sobie go dostosować do własnych potrzeb. Opłaca się to zrobić choćby dla jednego zmienionego znaku, gdyż sprawa jest bardzo prosta.

Domyślnie Symfony wykorzystuje szkielet, który dostępny jest w jej źródłach w katalogu: lib/task/generator/skeleton.

Aby zmienić domyślny wygląd modułów, wystarczy skopiować ten katalog do własnego projektu do katalogu data. Czyli w katalogu projektu, w data/skeleton powinniśmy mieć takie katalogi jak:

• app
• module
• project

Teraz pozostaje tylko edytować zawartość katalogu data/skeleton/module (nie zmieniamy w źródłach tylko tokena ##MODULE_NAME##), a po utworzeniu nowego modułu, w standardowy sposób, wszystko będzie wyglądać po naszemu.

Co warto zmienić, czyli co ja zmieniam?

• Usuwam zbędne komentarze na początku pliku actions.class.php.
• Formatuję sobie kod wg lepszego standardu (np. taby zamiast spacji).
• Zmieniam dziedziczenie w akcjach na myActions.
• Przygotowuję sobie akcje i widoki pod kątem projektu. Zwykle jest to jakiś prosty CRUD, w którym wystarczy wykonać kilka razy search & replace.

Zmiana domyślnego wyglądu aplikacji i projektu

Jeśli spojrzymy na zawartość katalogu skeleton to widać, że nie tylko moduł może być dostosowany do naszych potrzeb. Ja jednak w katalogach do aplikacji nie mieszałem, bo zbyt rzadko się je generuje, a wygląd początkowy jest zadowalający. Natomiast katalog do generowania projektu musiałby by edytowany w źródłach Symfony co nie jest zbyt fajne. Ale może trafią się komuś takie projekty, że i ten „ficzer” znajdzie zastosowanie.

Podobne wpisy:

1. Dostosowanie grep-a do SVN i Symfony
2. Logowanie do pliku wszystkich zapytań w PostgreSQL
3. Walidacja jednego pola formularza w symfony

W pierwszej edycji „Bardzo ciężkiego quizu PHP” sprawdzaliśmy naszą wiedzę na temat porównań. Tym razem na ruszt poszła funkcja count().

Na początek rzućmy krótko okiem do manuala, żeby sprawdzić co ona robi.

count — Count all elements in an array, or properties in an object

Ok, proste. Tak więc spróbujmy zgadnąć do się stanie gdy wywołamy ja na paru różnych rzeczach.

Żeby zobaczyć prawidłową odpowiedź trzeba zaznaczyć sobie odpowiednią komórkę.

Jak Wam poszło?

Podobne wpisy:

1. Bardzo ciężki quiz PHP
2. Krótko: Vim i powolna edycja plików PHP

PHP pozwala na połączenie tablic ze sobą za pomocą operatora + lub funkcji array_merge. Zależnie od przypadku mogą one zwracać różne wyniki.

Łączenie za pomocą operatora +

„Plus” to jedyny operator, którym można wykonywać jakieś operacje na tablicach. Pozostałe służą do porównań. Jego działanie polega na tym, że do tablicy po lewej stronie operatora dołączane są elementy z tablicy z prawej strony, z wyjątkiem sytuacji gdzie klucz się powtarza. Elementy z „prawej” tablicy o kluczu istniejącym już w „lewej” są pomijane. Do porównywania kluczy wykorzystywany jest niejawnie operator ===.

Przykładowo mając następujące tablice:

$a = array ('1st' => 'first', '2nd' => 'second');
$b = array ('1st' => 'zonk1', '2nd' => 'zonk2', '3rd' => 'zonk3');
$c = array ('3rd' => 'final3', '4th' => 'final4');

Wynik „dodawania” tablic ($a + $b + $c) będzie wyglądał tak:

array(4) {
  ["1st"]=>
  string(5) "first"
  ["2nd"]=>
  string(6) "second"
  ["3rd"]=>
  string(5) "zonk3"
  ["4th"]=>
  string(6) "final4"
}

Jak można się już domyślać — mając tablice, w których kluczy jawnie nie podajemy (czyli są one liczbami naturalnym zaczynającymi się od zera), rezultat łączenia może nie być zgodny z oczekiwanym:

$a = array ('php', 'html');
$b = array ('js', 'symfony', 'css');

$a + $b daje nam:

array(3) {
  [0]=>
  string(3) "php"
  [1]=>
  string(4) "html"
  [2]=>
  string(3) "css"
}

Jeżeli chcemy, żeby żadna wartość nie została pominięta, lepiej zainteresować się array_merge.

Łączenie za pomocą array_merge

Działanie array_merge może już być bardziej intuicyjne. Jednak trzeba wiedzieć, że łączenie wartości przebiega inaczej, zależnie od tego czy mamy do czynienia ze zwykłą tablicą (z kluczami 0, 1, 2…) czy tablicą asocjacyjną (zwaną również mapą lub hashem).

W przypadku zwykłych tablic do elementów pierwszej dołączane są elementy drugiej. Przykładowo:

$a = array ('php', 'html');
$b = array ('js', 'symfony', 'css');

Wynik array_merge ($a, $b):

array(5) {
  [0]=>
  string(3) "php"
  [1]=>
  string(4) "html"
  [2]=>
  string(2) "js"
  [3]=>
  string(7) "symfony"
  [4]=>
  string(3) "css"
}

Takie dołączanie następuje również, gdy do array_merge podamy jedną tablicę zwykłą i jedną asocjacyjną. Żadna wartość wtedy nie przepadnie.

Natomiast w przypadku samych tablic asocjacyjnych klucze zaczynają mieć znaczenie. Wartość z tablicy drugiej (lub kolejnej, bo można łączyć wiele tablic) nadpisze wartość z tablicy poprzedzającej, jeśli posiadała ona taki sam klucz. Przykładowo dla tablic:

$a = array ('1st' => 'first', '2nd' => 'second');
$b = array ('1st' => 'zonk1', '2nd' => 'zonk2', '3rd' => 'zonk3');
$c = array ('3rd' => 'final3', '4th' => 'final4');

Wynik array_merge ($a, $b, $c) będzie następujący:

array(4) {
  ["1st"]=>
  string(5) "zonk1"
  ["2nd"]=>
  string(5) "zonk2"
  ["3rd"]=>
  string(6) "final3"
  ["4th"]=>
  string(6) "final4"
}

Podobne wpisy:

1. Epic: ALERT w PHP i niespodziewane białe ekrany śmierci
2. PHP: Sortowanie obiektów po dacie utworzenia
3. Bardzo ciężki quiz PHP

Dość typową sytuacją w każdym projekcie jest fakt, że część plików lub katalogów nie powinna się znajdować pod kontrolą wersji. Przykładami takich plików są:

• generowane pliki tymczasowe,
• logi,
• pliki cache,
• pliki konfiguracyjne, inne dla każdej kopii roboczej,
• pliki tworzone przez edytor tekstu lub IDE,
• zbyt duże pliki, by je wysyłać do repozytorium.

Pliki można ignorować na dwa sposoby.

Ignorowanie globalne

Każdy użytkownik może ustawić sobie dowolne ignorowanie plików według typowych dla konsol linuksowych masek. Aby to zrobić należy wyedytować plik config, który powinien znajdować się w katalogu .subversion w katalogu domowym użytkownika (Linux) lub w jego profilu (Windows). Interesująca nas opcja nazywa się global-ignores. Domyślnie jest ona objęta komentarzem a jej domyślna wartość wygląda następująco:

global-ignores = *.o *.lo *.la #*# .*.rej *.rej .*~ *~ .#* .DS_Store

I właśnie takie pliki są domyślnie ignorowane. Dlatego też, chcąc dodać kolejną maskę, nie powinniśmy raczej kasować początkowych wartości (chociaż oczywiście możemy). Ja tutaj dodałem sobie tylko pliki tymczasowe jakie generuje mi Vim:

global-ignores = *.o *.lo *.la #*# .*.rej *.rej .*~ *~ .#* .DS_Store *.swp *.swo *.swn

Maski lub nazwy plików działają również na katalogi.

Ignorowanie lokalne

Subversion dostarcza mechanizm pozwalający na ustawianie dowolnych właściwości (properties) plikom i katalogom znajdującym się pod jego kontrolą. Kilka właściwości jest zdefiniowanych od razu — każda z nich zaczyna się od svn: (jak np. svn:executable). Prawdopodobnie najpopularniejszą z nich jest svn:ignore, służąca właśnie do ignorowania plików.

Musicie pamiętać, że właściwość svn:ignore można ustawiać tylko na katalogach (tj. plik nie możne przechowywać informacji o tym, że on sam ma być zignorowany). Jej wartością mogą być nazwy plików, nazwy katalogów lub maski oddzielone znakiem nowej linii. Innymi słowy — aby zignorować pojedynczy plik, musimy edytować właściwości katalogu, w którym się znajduje, a nie tegoż pliku. Wg mnie najwygodniejszym sposobem ustawiania ignorowania jest wykorzystanie podpolecenia propedit (skrót pe), które to otwiera nam edytor, dzięki czemu możemy wygodnie wpisać nazwy do ignorowania.

Przykład: zignorowanie plików log1, log2, katalogu test i wszyskich plików kończących się na „a” w bieżącym katalogu

Otwieramy edytor dla właściwości svn:ignore:

svn pe svn:ignore .

Po czym w edytorze wpisujemy:

log1
log2
test
*a

Możemy sprawdzić czy wszystko jest ok:

> svn proplist -v
Properties on '.':
  svn:ignore
    log1
    log2
    test
    *a

Pozostaje tylko zakomitować zmiany:

svn ci -m "Trochę bezsensu, ale dobry jako przykład svn:ignore"

Przykład: zignorowanie istniejącego, niepustego katalogu z cachem

Zakładając, że sam katalog powinien znaleźć się w repozytorium, natomiast jego zawartość nie. Najpierw dodajemy katalog do svn:

svn add cache --depth empty

Gdzie cache jest nazwą katalogu, a parametr --depth empty powoduje, że pliki wewnątrz nie zostaną dodane.
Następnie ustawiamy ignorowanie wszystkich plików w katalogu, za pomocą podpolecenia propset (skrót pe):

svn propset svn:ignore \* cache

Gwiazdka musi być wyeskejpowana, żeby nasz shell jej nie zinterpretował i nie podstawił wszystkich nazw plików z bieżącego katalogu. Teraz pozostaje już tylko zatwierdzenie zmian w repozytorium:

svn ci -m "svn:ignore na zawartość katalogu cache"

Przykład negatywny: ignorowanie dwa lub więcej katalogi niżej

Załóżmy, że chcemy zignorować pliki ./log/2010/*. Może wydawać się intuicyjne ustawienie svn:ignore w bieżącym katalogu na wartość log/2010/*. Jednak taki zapis nie zadziała. Musimy ustawić właściwość na katalog bezpośrednio nadrzędny, czyli:

svn ps svn:ignore \* log/2010

Podobne wpisy:

1. Uprawnienia plików w repo SVN
2. Vim: Znajdowanie plików w podkatalogach
3. Krótko: Vim i powolna edycja plików PHP

public static function doSelect (Criteria $criteria, PropelPDO $con = null)
{
  if (!$criteria->getOrderByColumns())
  {
     $criteria->addAscendingOrderByColumn (self::YEAR);
     $criteria->addAscendingOrderByColumn (self::MONTH);
     $criteria->addAscendingOrderByColumn (self::DAY);
  }
  return parent::doSelect ($criteria, $con);
}

Warunek if umożliwia nam zdefiniowanie dowolnego innego sortowania wcześniej. W przypadku, gdy jakaś metoda (np. getAll) nie definiowała sortowania za pomocą obiektu Criteria — zostanie użyte domyślne (tutaj: po dacie).

Podobne wpisy:

1. Formularze Symfony: select ograniczony przez wartość innego pola
2. PHP: Sortowanie obiektów po dacie utworzenia
3. Symfony: Paginacja przy własnych/nietypowych warunkach SQL

Opis na przykładzie Propela.

Problem

Jak ograniczyć liczbę opcji w sfWidgetFormChoice na podstawie wartości z innego pola formularza. Mowa o ograniczeniu stałym, zdefiniowanym w klasie formularza.

Rozwiązanie

Będąc w klasie formularza mamy dostęp do wartości odpowiadającego obiektu, tylko gdy dany formularz zostanie zainicjalizowany poprzez podanie obiektu do konstruktora (czyli przykładowo $this->form = new SampleForm ($sample_object)). Wtedy możemy pobrać jakąś informację z obiektu i na jej podstawie stworzyć Criteria ograniczające:

$c = new Criteria();
$c->add (APeer::XYZ, $this->getObject()->getAsd());
$this->widgetSchema['asd'] = new sfWidgetFormPropelChoice (array (
    'model' => 'B', 'criteria' => $c));

Podobne wpisy:

1. Walidacja jednego pola formularza w symfony
2. Symfony+Propel: domyślne sortowanie
3. Symfony: Paginacja przy własnych/nietypowych warunkach SQL