Procedura i zmienna liczba zmiennych

Witam,
mam problem i boje się, że może być coś "grubszego"..
Mianowicie dotychczas robiłem (i testowałem) procedurę jedynie dla "stałych" danych.., jednakże docelowo procedura ma być uniwersalna i tutaj pojawił się problem ze zmiennymi...

Aktualnie procedura wygląda tak : (fragment)

DELIMITER $$
 CREATE PROCEDURE proc()
 BEGIN
     DECLARE value1 INT;
     DECLARE value2 INT;
     DECLARE value3 INT;
     DECLARE value4 INT;
     DECLARE value5 INT;

     DECLARE cur1 CURSOR FOR SELECT val1, val2, val3, val4, val5 FROM tab AS t1

     DROP TABLE IF EXISTS temp_table;
     CREATE TEMPORARY TABLE IF NOT EXISTS temp_table (val1 INT, val2 INT, val3 INT, val4 INT, val5);

     OPEN cur1;

       FETCH cur1 INTO value1, value2, value3, value4, value5;

        SELECT count(1) INTO var FROM tab WHERE val1= value1;

      ...

     CLOSE cur1;
 DELIMITER ;

O co chodzi?

Procedura ma przetwarzać dane tabel, które posiadają różną liczę kolumn 'value'..
W powyższym przypadku jest ich 5 i jak widać zastosowane jest 5 zmiennych, które następnie są wykorzystywane do działania na kursorze (i jeszcze w kilku miejscach..).

I teraz pytanie / problem - czy jest możliwość "dynamicznego" deklarowania różnej ilości zmiennych ?

     DECLARE value1 INT;
     DECLARE value2 INT;
     DECLARE value3 INT;
     DECLARE value4 INT;
     DECLARE value5 INT;

Teoretycznie mógłbym jeszcze przekazywać te wartości bezpośrednio do procedury (IN), ale wtedy musiałbym utworzyć (chyba) wiele procedur dopasowanych do liczby danych wejściowych..

A może jest jakieś inne rozwiązanie tego problemu, które nie znam/ nie widzę ? (oby..)

możesz użyć temporary table jak tablicę intów

@abrakadaber - hm.. nie za bardzo widzę jak można tutaj wykorzystać tabele tymczasowe, bo żeby tworzyć tabele o różnej długości muszę podać różną liczbę wartości (value) do procedury które następnie tą tabele utworzą.. a jak to zrobić ? (to chyba też się wiąże z utworzeniem wielu procedur dla każdej liczby zmiennej ? )

Może mógłbyś to bardziej przybliżyć / pokazać na (pseudo) kodzie..?

ps. tabele tymczasową ja de facto tworzę w tej procedurze, ale w całkiem innym celu (tzn. aby uzyskać tabele przetworzoną, której nie da się uzyskać ze "zwyklego" zapytania.. ale to inna sprawa..)

..także bardzo proszę o dalsze wskazówki :)

dokładnie tak samo jak tablicę - pola id int i value w zależności od tego co chcesz w niej przechowywać i zamiast value1, value2, ... masz select value from tabela where id=1 dla value1, select value from tabela where id=2 dla value2 itd. Oczywiście możesz zrobić select bez warunku i mieć wszystkie wartości "od razu". Nie ma ograniczenia ile ich tam będziesz miał. Innej opcji nie widzę ponieważ mysql nie ma tablic, a to chyba jedyna struktura która daje możliwość "posiadania dynamicznej" ilości zmiennych w stored proc.

No i oczywiście składanie zapytania będziesz musiał zrobić trochę inaczej - wygenerować je dynamicznie do zmiennej varchar a potem dopiero uruchomić (execute). Nie jestem w stanie wymyślić takiego zapytania, które miało by operować na nieznanej z góry liczbie warunków

Ja mam wrażenie że problem to jest z designem tej bazy, a nie z napisaniem procedury/zapytania.
Nie dało się po prostu zrobić tabeli gdzie miałbyś dwa pola:
wartość i id?
I zamiast mieć w bazie:

v1|v2|v3|v4|v5
1 | 2 | 3 | 4 | 5
2 | 3 | 4 | 5 | 6

byłoby

v | id
1 | 1
2 | 1
3 | 1
4 | 1
5 | 1
2 | 2
3 | 2
4 | 2
5 | 2
6 | 2

Wtedy pozbyłbyś się już problemów z operowaniem na tablicy o róznej liczbie elementów. Ale nadal nie napisałeś CO właściwie chcesz potem z tymi danymi robić i jak na nich operować więc trudno powiedzieć czy takie rozwiązanie ma u ciebie sens.

@abrakadaber - szczerze, to tak to sobie wyobrażałem.. Pewnie nie jasno się wyraziłem także poniżej przedstawie Tobie i @Shalom jeszcze inaczej problem..

Chodzi o to, że do procedury proc() będzie podawana nazwa tabeli (defacto będzie to id, które razem będzie tworzyć nazwę tabeli).. przykład:

tab_nr_(id)
tab_nr_1
tab_nr_2
itd

gdzie każda z tych tabel ma zmienną liczbę kolumn.. Stąd potrzebne jest zadeklarowanie zmiennej liczby zmiennych w zależności od tabeli..

Rozumiem że mógłbym to zrobić tak:

1)podaje id = 2 tworzące nazwę tabeli
2)robię select typu: SELECT * FROM tab_nr_2, gdzie mogę zobaczyć jaka jest liczba kolumn i następnie na tej podstawie utworzyć tabele tymczasową z otrzymaną liczbą kolumn, które będą następnie "robić" za zmienne (jeszcze nie wiem dokładnie jakby to "od strony kodu" miało wyglądać..)
3)
cytując: "No i oczywiście składanie zapytania będziesz musiał zrobić trochę inaczej - wygenerować je dynamicznie do zmiennej varchar a potem dopiero uruchomić.." - tylko wtedy korzystamy z jednej zmiennej? Hm.. bo jeśli każda zmienna ma być osobna to znowu wracamy do problemu "dynamicznego" generowania zmiennych..

Ogólnie odpowiadając jeszcze na pytania @shalom'a to niestety bazy danych nie mogę zmienić, a CO chce przetwarzać dalej to chyba jest to mało istotne (jest tam sortowanie i usuwanie niektórych wierszy w kontekscie postawionych warunków przetwarzania), bo to co mnie interesuje to - jak utworzyć kursor, którego liczba kolumn jest zmienna w zależności od tabeli..

DECLARE cur1 CURSOR FOR SELECT val1, val2, val3, val4, val5 FROM tab AS t1
 
CREATE TEMPORARY TABLE IF NOT EXISTS temp_table (val1 INT, val2 INT, val3 INT, val4 INT, val5);
 
FETCH cur1 INTO value1, value2, value3, value4, value5;

a to wszystko de facto jest oparte o zadeklarowane zmienne na początku procedury..

Tak jak już wspomniałem, jedyne rozwiązanie jakie mi przychodzi do głowy to przygotowanie n wersji procedury z różną ilością parametrów wejściowych, np.

call proc(val1,val2,val3)
call proc(val1,val2,val3,val4,val5)
call proc(val1,val2,val3,val4,val5,val6,val7,val8,val9,val10)

-.-

ps. Czy coś takiego (zmienna liczba parametrów podawanych do procedury) jest możliwa w bardziej zaawansowanych bazach danych, czy mysql jak zwykle "ułomny" ?

Jeśli masz tak skonstruowaną bazę, że masz tabele:
tab_nr_1
tab_nr_2
to nie znaczy, że masz skopaną bazę...
Masz ją zje..ną. I to na maksa.

@Marcin.Miga - hm.. nie jest dobrze, ale teraz nie mam już ruchu.. :(

Także jakby ktoś miał jeszcze jakiś sugestie na tak postawiony przeze mnie problem to bardzo proszę o wypowiedź!

A po co ci w ogóle te zmienne? Zupełnie nie kumam, co chcesz zrobić - może mógłbym ci pomóc, gdybym wiedział o co chodzi... Zmienne w SQL są tylko pomocnicze - da się bez nich żyć.

Marcin.Miga napisał(a):

A po co ci w ogóle te zmienne? Zupełnie nie kumam, co chcesz zrobić - może mógłbym ci pomóc, gdybym wiedział o co chodzi... Zmienne w SQL są tylko pomocnicze - da się bez nich żyć.

OK, to uzupełniając poprzednie moje posty..

Mam następującą procedure:
(jest ona okrojona/przerobiona po to aby nie "zaciemniać", ale problem został tutaj ujęty)

DELIMITER $$
 CREATE PROCEDURE proc()
 BEGIN
     DECLARE tabID INT;
     DECLARE value1 INT;
     DECLARE value2 INT;
     DECLARE value3 INT;
     DECLARE value4 INT;
     DECLARE value5 INT;
 
     DECLARE cur1 CURSOR FOR SELECT tab_id, ,val1, val2, val3, val4, val5 FROM tab_nr_1
                        ORDER BY val1;
 
     DROP TABLE IF EXISTS temp_table;
     CREATE TEMPORARY TABLE IF NOT EXISTS temp_table (tab_id INT, val1 INT, val2 INT, val3 INT, val4 INT, val5 INT);
 
     OPEN cur1;
 
       FETCH cur1 INTO value1, value2, value3, value4, value5;
 
        SELECT COUNT(1) INTO var FROM tab WHERE val1= value1;
 
        INSERT INTO temp_table (tab_id, val1, val2, val3, val4, val5) VALUES (tabID, value1,value2,value3, value4, value5);

      ...
 
     CLOSE cur1;
 DELIMITER ;

Zamieszczony przeze mnie przykład za wiele nie robi, lecz jest to tylko przykład.

O co chodzi?

Powiedzmy, że jako parametr do procedury podaje id, np. 2. W samej procedurze musi być konkatenacja nazwy w stylu

SET tableName = CONCAT('table_nr_',@id);

I teraz chciałbym wyciągnąć wszystkie kolumny danej tabeli z tym, że tabele mają różną ilość kolumn 'val(x)', a z racji tego iż muszę wykorzystać kursor deklaruje sobie wcześniej zmienne aby móc do nich przypisać wartości..

Patrząc inaczej mógłbym te zmienne przekazywać jako parametry do procedury, ale wtedy procedura musi raczej posiadać stałą ilość tych parametrów..

Nie wiem jak to inaczej Wam przekazać..

Chyba, że wynik "końcowy", który uzyskuje po "przekształceniu" tabeli przy pomocy tej procedury można uzyskać "jednym, zwykłym" zapytaniem SQL.. (ja tego niestety nie potrafiłem zrobić i stwierdziłem, że należy tu posiłkować się np. procedurą.. [prywata: ale chętnym myślę, że już w ramach zlecenia mógłbym bliżej naświetlić (podesłać rzeczywisty przykład z kodem), aby sprawdzić czy da się to zrobić samym zapytaniem.. ]

NAPISZ WRESZCIE DOKŁADNIE CO CHCESZ ROBIĆ W TEJ PROCEDURZE BO TAK TO DO USRANEJ ŚMIERCI MOŻEMY GDYBAĆ

Zmotywowany odpowiedzią @abrakadaber i @furious programming postanowiłem wyłożyć wszystko co mam na temat tej procedury i jej funkcjonalności..

Input do procedury to:

+--------+---------+-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+---------+
| tab_id | user_id | sum_value | value1 | value2 | value3 | value4 | value5 | value6 | value7 | value8 | value9 | value10 |
+--------+---------+-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+---------+
|      5 |      12 |   73.3001 |  5.000 |  9.000 |  9.200 |  5.000 | 10.001 |  9.100 |  8.000 |  6.000 |  7.000 |   5.000 |
|      6 |      10 |   80.8002 | 10.001 |  9.000 |  8.000 |  7.000 |  4.000 |  5.000 | 10.000 | 10.801 |  8.000 |   9.000 |
|      7 |      16 |   80.8001 | 10.001 |  9.000 |  8.000 |  7.000 |  4.000 |  5.000 | 10.000 | 10.800 |  8.000 |   9.000 |
|      8 |      15 |   68.2000 |  6.000 |  6.000 |  7.000 |  5.000 |  4.000 |  9.000 |  8.000 |  6.000 | 10.000 |   7.200 |
|      9 |      17 |   87.5000 | 10.000 |  9.000 |  8.000 |  6.400 | 10.100 |  7.000 | 10.000 | 10.800 |  8.000 |   8.200 |
|     10 |      14 |   73.3001 |  5.000 |  9.000 |  9.200 | 10.000 | 10.001 |  9.100 |  7.000 |  4.000 |  5.000 |   5.000 |
|     11 |       9 |   73.3001 |  4.000 |  9.000 | 10.000 |  5.000 | 10.001 |  9.100 |  8.000 |  6.000 |  7.000 |   5.000 |
|     12 |       9 |   67.1001 |  3.000 |  7.000 | 10.000 |  5.000 | 10.001 |  6.000 |  8.000 |  6.000 |  7.000 |   5.000 |
+--------+---------+-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+---------+

natomiast output:

+--------+---------+-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+---------+
| tab_id | user_id | sum_value | value1 | value2 | value3 | value4 | value5 | value6 | value7 | value8 | value9 | value10 |
+--------+---------+-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+---------+
|      9 |      17 |   87.5000 | 10.000 |  9.000 |  8.000 |  6.400 | 10.100 |  7.000 | 10.000 | 10.800 |  8.000 |   8.200 |
|      6 |      10 |   80.8002 | 10.001 |  9.000 |  8.000 |  7.000 |  4.000 |  5.000 | 10.000 | 10.801 |  8.000 |   9.000 |
|      7 |      16 |   80.8001 | 10.001 |  9.000 |  8.000 |  7.000 |  4.000 |  5.000 | 10.000 | 10.800 |  8.000 |   9.000 |
|     10 |      14 |   73.3001 |  5.000 |  9.000 |  9.200 | 10.000 | 10.001 |  9.100 |  7.000 |  4.000 |  5.000 |   5.000 |
|     11 |       9 |   73.3001 |  4.000 |  9.000 | 10.000 |  5.000 | 10.001 |  9.100 |  8.000 |  6.000 |  7.000 |   5.000 |
|      5 |      12 |   73.3001 |  5.000 |  9.000 |  9.200 |  5.000 | 10.001 |  9.100 |  8.000 |  6.000 |  7.000 |   5.000 |
|      8 |      15 |   68.2000 |  6.000 |  6.000 |  7.000 |  5.000 |  4.000 |  9.000 |  8.000 |  6.000 | 10.000 |   7.200 |
+--------+---------+-----------+--------+--------+--------+--------+--------+--------+--------+--------+--------+---------+

Co się stało ?

Z racji tego, iż wynik ma stanowić swoisty ranking, dane zostały uszeregowane według kolumny sum_value (malejąco) oraz zostało "rozstrzygnięte", który użytkownik powinien być wyżej dla tych samych wyników w kolumnie sum_value.

Jak wygląda to rozstrzygnięcie?

Jeśli wartość sum_value jest równa dla danego użytkownika to powinien "wygrać" ten wynik, który ma większą ilość 10-tek, potem 9-tek, 8-ek, itd.. Analizując wyniki użytkowników user_id = 9 i 14 sprawdzamy ile ma 10-tek (mają po dwie); sprawdzamy liczbę 9-tek (pierwszy ma dwie a drugi trzy), wiec user_id = 14 wygrywa i jest wyżej.

I jeszcze jedno - użytkownicy mogą mieć kilka pozycji wyników (jak np. user_id = 9), to w wyniku końcowym uwzględniany jest tylko jeden jego wynik (oczywiście najwyższy..).

I właśnie tego typu operacje robię w owej procedurze, gdzie wynik końcowy jest tworzony w tabeli tymczasowej, bo nie potrafiłem tego zrobić jednym "spójnym" zapytaniem..
W procedurze używam w sumie **dwóch kursorów **- najpierw usuwam wyniki powtarzające się dla danego użytkownika a następnie drugim kursorem wyjmuje wyniki posortowane według atrybutu sum_value z uwzględnieniem wyników cząstkowych -- i z tego tworzę wynik końcowy..

edit::
Wrzucam kod tabeli dla chętnych, którzy chcą pomóc

DROP TABLE IF EXISTS `tab_nr_7`;
CREATE TABLE `tab_nr_7` (
  `tab_id` int(10) NOT NULL AUTO_INCREMENT,
  `user_id` int(10) NOT NULL,
  `sum_value` double(7,4) DEFAULT NULL,
  `value1` double(5,3) DEFAULT NULL,
  `value2` double(5,3) DEFAULT NULL,
  `value3` double(5,3) DEFAULT NULL,
  `value4` double(5,3) DEFAULT NULL,
  `value5` double(5,3) DEFAULT NULL,
  `value6` double(5,3) DEFAULT NULL,
  `value7` double(5,3) DEFAULT NULL,
  `value8` double(5,3) DEFAULT NULL,
  `value9` double(5,3) DEFAULT NULL,
  `value10` double(5,3) DEFAULT NULL,
  PRIMARY KEY (`tab_id`)
) ENGINE=InnoDB AUTO_INCREMENT=12 DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;

--
-- Dumping data for table `tab_nr_7`
--
INSERT INTO `tab_nr_7` VALUES (5,12,73.3001,5.000,9.000,9.200,5.000,10.001,9.100,8.000,6.000,7.000,5.000),(6,10,80.8002,10.001,9.000,8.000,7.000,4.000,5.000,10.000,10.801,8.000,9.000),(7,16,80.8001,10.001,9.000,8.000,7.000,4.000,5.000,10.000,10.800,8.000,9.000),(8,15,68.2000,6.000,6.000,7.000,5.000,4.000,9.000,8.000,6.000,10.000,7.200),(9,17,87.5000,10.000,9.000,8.000,6.400,10.100,7.000,10.000,10.800,8.000,8.200),(10,14,73.3001,5.000,9.000,9.200,10.000,10.001,9.100,7.000,4.000,5.000,5.000),(11,9,73.3001,4.000,9.000,10.000,5.200,10.001,9.100,8.000,6.000,7.000,5.000),(12,9,67.1001,3.000,7.000,10.000,5.000,10.001,6.000,8.000,6.000,7.000,5.000);

edit 2:
Dorzucam procedurę: (jakoś jest pewnie wątpliwa, ale się "kompiluje"..)

DROP PROCEDURE IF EXISTS RANKING;
DELIMITER $$
 CREATE PROCEDURE ranking()
 BEGIN
     DECLARE t_tab_id INT(10);
     DECLARE t_user_id INT(10);
     DECLARE t_sum_value DOUBLE(7,4);
     DECLARE t_value1 DOUBLE(5,3);
     DECLARE t_value2 DOUBLE(5,3);
     DECLARE t_value3 DOUBLE(5,3);
     DECLARE t_value4 DOUBLE(5,3);
     DECLARE t_value5 DOUBLE(5,3);
     DECLARE t_value6 DOUBLE(5,3);
     DECLARE t_value7 DOUBLE(5,3);
     DECLARE t_value8 DOUBLE(5,3);
     DECLARE t_value9 DOUBLE(5,3);
     DECLARE t_value10 DOUBLE(5,3);

     DECLARE globalRowCounter INTEGER DEFAULT 0;
     DECLARE numRowsOfCurs1 INTEGER DEFAULT 0;
     DECLARE numRowOfTotalValue INTEGER DEFAULT 0;
    
    # kursor z wyłonieniem najlepszych (pojedynczych) wyników dla konkretnych zawodników
     DECLARE cur1 CURSOR FOR SELECT tab_id,user_id,sum_value,value1,value2,value3,value4,value5
        ,value6,value7,value8,value9,value10
        FROM tab_nr_7 AS t1
        WHERE (SELECT count(1) FROM tab_nr_7 AS t2 WHERE t2.user_id = t1.user_id AND t2.sum_value > t1.sum_value AND t2.user_id ) = 0
        ORDER BY sum_value DESC;

     DROP TABLE IF EXISTS t_table;
     CREATE TEMPORARY TABLE IF NOT EXISTS t_table
       (tab_id INT(10), user_id INT(10), sum_value DOUBLE(6,4), value1 DOUBLE(5,3),
            value2 DOUBLE(5,3),value3 DOUBLE(5,3),value4 DOUBLE(5,3),value5 DOUBLE(5,3),value6 DOUBLE(5,3),
            value7 DOUBLE(5,3),value8 DOUBLE(5,3),value9 DOUBLE(5,3),value10 DOUBLE(5,3));

     OPEN cur1;
     SELECT FOUND_ROWS() INTO numRowsOfCurs1;
     mainLoop: LOOP

       FETCH cur1 INTO t_tab_id,t_user_id,t_sum_value, t_value1,t_value2,t_value3,
        t_value4,t_value5,t_value6,t_value7,t_value8,t_value9,t_value10;

        SELECT count(1) INTO numRowOfTotalValue FROM tab_nr_7 WHERE sum_value = t_sum_value;

        IF numRowOfTotalValue = 1 THEN
            INSERT INTO t_table (tab_id,user_id,sum_value,value1,value2,value3,value4,value5
            ,value6,value7,value8,value9,value10)
           VALUES (t_tab_id, t_user_id,t_sum_value, t_value1,t_value2,t_value3,
            t_value4,t_value5,t_value6,t_value7,t_value8,t_value9,t_value10);
        ELSE
            BLOCK2: BEGIN
                DECLARE tt_tab_id INT(10);
                DECLARE tt_user_id INT(10);
                DECLARE tt_sum_value DOUBLE(7,4);
                DECLARE tt_value1 DOUBLE(5,3);
                DECLARE tt_value2 DOUBLE(5,3);
                DECLARE tt_value3 DOUBLE(5,3);
                DECLARE tt_value4 DOUBLE(5,3);
                DECLARE tt_value5 DOUBLE(5,3);
                DECLARE tt_value6 DOUBLE(5,3);
                DECLARE tt_value7 DOUBLE(5,3);
                DECLARE tt_value8 DOUBLE(5,3);
                DECLARE tt_value9 DOUBLE(5,3);
                DECLARE tt_value10 DOUBLE(5,3);

                DECLARE tt_liczba  INT;
                DECLARE numRowsOfCurs2 INTEGER DEFAULT 0; 
                DECLARE rowCounterLoop INTEGER DEFAULT 0;
                
                # kursor z posortowanymi wynikami dla konkretnego sum_value
                DECLARE cur2 CURSOR FOR SELECT * FROM tab_nr_7 as t JOIN (
                SELECT user_id, MAX(POWER(10, value1)+POWER(10, value2)+POWER(10, value3)+POWER(10, value4)+POWER(10, value5)+POWER(10, value6)+POWER(10, value7)+POWER(10, value8)+POWER(10, value9)+POWER(10, value10)) liczba FROM tab_nr_7 as t
                WHERE sum_value = t_sum_value
                GROUP BY user_id) x ON t.user_id=x.user_id AND POWER(10, value1)+POWER(10, value2)+POWER(10, value3)+POWER(10, value4)+POWER(10, value5)+POWER(10, value6)+POWER(10, value7)+POWER(10, value8)+POWER(10, value9)+POWER(10, value10)=x.liczba
                ORDER BY liczba DESC;

                OPEN cur2;
                SELECT FOUND_ROWS() INTO numRowsOfCurs2;

                subLoop: LOOP
                FETCH cur2 INTO tt_tab_id,tt_user_id,tt_sum_value, tt_value1,tt_value2,tt_value3,
                    tt_value4,tt_value5,tt_value6,tt_value7,tt_value8,tt_value9,tt_value10,tt_user_id,tt_liczba;

                INSERT INTO t_table (tab_id,user_id,sum_value,value1,value2,value3,value4,value5
                ,value6,value7,value8,value9,value10)
                VALUES (tt_tab_id, tt_user_id,tt_sum_value, tt_value1,tt_value2,tt_value3,
                tt_value4,tt_value5,tt_value6,tt_value7,tt_value8,tt_value9,tt_value10);
  
                SET rowCounterLoop := rowCounterLoop+1;

                    IF rowCounterLoop <= numRowsOfCurs2-1 THEN
                    BEGIN
                    FETCH NEXT FROM cur1 INTO t_tab_id,t_user_id,t_sum_value, t_value1,t_value2,t_value3,t_value4,t_value5
                    ,t_value6,t_value7,t_value8,t_value9,t_value10;
                    END;
                    END IF;
                
                    IF rowCounterLoop >= numRowsOfCurs2 THEN
                    BEGIN
                     SET globalRowCounter := globalRowCounter+numRowsOfCurs2-1; 
                     #FETCH NEXT FROM cur1 INTO t_tab_id,t_user_id,t_sum_value, t_value1,t_value2,t_value3,
                     #t_value4,t_value5,t_value6,t_value7,t_value8,t_value9,t_value10;
                     CLOSE cur2;
                     LEAVE subLoop;
                    END;
                END IF;
                
            END LOOP subLoop;      
            END BLOCK2;
        END IF;

        SET globalRowCounter := globalRowCounter+1;
        IF globalRowCounter >= numRowsOfCurs1 THEN
        LEAVE mainLoop;
            END IF;

     END LOOP mainLoop;
     CLOSE cur1;

     SELECT tab_id,user_id,sum_value,value1,value2,value3,value4,value5
        ,value6,value7,value8,value9,value10 FROM tab_nr_7;

     SELECT tab_id,user_id,sum_value,value1,value2,value3,value4,value5
        ,value6,value7,value8,value9,value10 FROM t_table;
 END $$

 DELIMITER ;
 CALL ranking();

Widzę, że już kiedyś w tym pomgłem. Znowu mam parę pytń, bo juz mam pomysła... (znowu lew strona klawiatury wariuje...)

1. "który ma większą ilość 10-tek, potem 9-tek, 8-ek," - interesuja nas tylko 10 jako wartosci całkowite, czy 10.100 (dokładne)?
2. Jaka jest wartość maksymalna w poszczegolnych value (czy dla kazdego value jest taka sama)?
3. Czy mozna nieco zmodyfikowac tabele?

a czy jest np. tab_nr_3, która ma pola od value1 do np. value15?

@abrakadaber - dokładnie, taka tabela właśnie może istnieć..

@Marcin.Miga - właściwie teraz właśnie to zauważyłem, że przy tej starej metodzie, którą kiedyś zaproponowałeś może pojawić się problem (bo mając np. 10.2 wynik jest większy nawet dla mniejszej ilości 9-tek stosując to do przykładu wyżej.. :( ..). Wcześniej było założenie, że działamy na INT'ach, potem okazało, że wyniki mogą byc do jednego miejsca po przecinku, czyli 0.0 - 10.9. Natomiast dlaczego reprezentacja 10.001 ? Ponieważ istnieje takie pojęcie jak 10-tka centralna, która jest mocniejsza niż zwykła 10-tka i w ten sposób jest to odwzorowywane w bazie..

Natomiast wracając do algorytmu "rozstrzygnięć" to poprawnie powinno być, że uwzględnia się tylko "całości", pomijając miejsca dziesiętne po przecinku.. (to trochę komplikuje..)