Discussion :

[schnito]

putain ! mais c vrai ! je l'ai deja fait en plus pour une autre page!!!

je suis trop con !

Je te tiens au courant ! Esperons que mon BOSS soit d'accord !

En tout cas merci beaucoup de me l'avoir rappelé !!!

[Mr N.]

Quelle vulgarité !

[schnito]

Je sais que ca ne résoud pas directement tes problèmes de performances, mais c'est un moyen de contournement qui a objectivement toute son utilité.

Voila, c ce que mon BOSS vient de me repondre ... il est ok poir la pagination, car c vrai que ca sera pratique, et ca optimisera encore plus, mais faut quand meme que je trouve une optimisation de traitement ...

pffff

[schnito]

mon tableau que la requete me renvoit et de ce style :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
$tabResult : 
                [NOMSHEMA]
                                  0=> Machin
                                  1=> Machin
                                  2=> Machin
                                  3=> Machin
                                  4=> Machin       
                                  5 => truc
                                  6=> truc 
...
 
                [TYPECHAMPS]
                                  0=> champs1
                                  1=> champs1
                                  2=> champs2
                                  3=> champs3
                                  4=> champs3  
                                  5 => champs3
                                  6=> champs4
...

Vous voyez que certaines valeurs se repetent, c ce qui donnera les rowspan de mes cellules du tableau HTML affiché ...

Pour calculer le nombre de repetition des valeurs, j'utilise mes boucles comme montré plus haut ...
Je determine le nombre de repetion d'une valeur sur in interval precis calculer auparavant ...

Je ne vois vraiment pas comment je pourrais faire autrement ...

si vous avez des idées n'hesitez pas ...

Merci !

[Mr N.]

rowspan ou colspan ?

[schnito]

rowspan !

comme ca je genere un tableau de ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
+----+----+----+----+----+
+    +    +    +    +----+
+    +    +    +----+----+
+    +    +    +    +----+
+    +    +----+----+----+
+    +    +    +    +----+
+    +    +    +----+----+
+    +    +    +    +----+
+    +----+----+----+----+
+    +    +    +    +----+
+    +    +    +----+----+
+    +    +    +    +----+
+    +    +----+----+----+
+    +    +    +    +----+
+    +    +    +----+----+
+    +    +    +    +----+
+----+----+----+----+----+

[Mr N.]

flute, je viens de faire un colspan. Je le mets quand même, histoire de ne pas avoir réflechis pour rien

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
<?php
 
$headers = array('c1', 'c2', 'c3', 'c4', 'c5', 'c6', 'c7', 'c8');
$body    = array(
    array('truc', 'truffe', 'truffe', 'truc', 'truc', 'truc', 'ok', 'ok'),
    array('champ 1', 'champ 1', 'champ 2', 'champ 3', 'champ 3', 'champ 3', 'champ 4', 'champ 4'),
    array('truc', 'truc', 'truffe', 'truffe', 'truc', 'ok', 'ok', 'ok')
);
 
 
class RowBuilder {
    var $cells;
    function RowBuilder($row) {
        $this->cells = array();
        foreach($row as $cell) {
            $this->add($cell);
        }
    }
    function _new($cell) {
        $this->cells[] = array('content' => $cell, 'nb' => 1);
    }
    function add($cell) {
        if (count($this->cells) == 0) {
            $this->_new($cell);
        } else {
            $current = count($this->cells) - 1;
            if ($this->cells[$current]['content'] == $cell) {
                $this->cells[$current]['nb']++;
            } else {
                $this->_new($cell);
            }
        }
    }
    function display() {
        echo '<tr>';
        foreach($this->cells as $cell) {
            echo '<td';
            if ($cell['nb'] > 1) {
                echo ' colspan="', $cell['nb'], '" ';
            }
            echo '>' , $cell['content'] , '</td>';
        }
        echo '</tr>';
    }
}
 
//--- Affichage
echo '<table border="1">';
 
echo '<tr>';
foreach($headers as $header) {
    echo '<th>' , $header , '</th>';
}
echo '</tr>';
 
foreach($body as $row) {
    $row_builder = new RowBuilder($row);
    $row_builder->display();
}
 
echo '</table>';
 
?>

[Mr N.]

rowspan !

comme ca je genere un tableau de ce genre :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
+----+----+----+----+----+
+    +    +    +    +----+
+    +    +    +----+----+
+    +    +    +    +----+
+    +    +----+----+----+
+    +    +    +    +----+
+    +    +    +----+----+
+    +    +    +    +----+
+    +----+----+----+----+
+    +    +    +    +----+
+    +    +    +----+----+
+    +    +    +    +----+
+    +    +----+----+----+
+    +    +    +    +----+
+    +    +    +----+----+
+    +    +    +    +----+
+----+----+----+----+----+

Tiens j'ai déjà vu ce tableau ascii quelque part...

[schnito]

oui, c'est deja toi qui m'avait aidé je crois !

mais j'avais finalement trouvé un autre algo...

[schnito]

Bon ben moi je vois pas ... n'y a t'il rien dans mon bout de source qui vous paraisse faisable plus rapidement ? ou qu'on pourrait zapper ??

[macbook]

Je me trompe ou on dirait la représentation d'un arbre ?

[Mr N.]

L'alternative de ma solution en rowspan, pour le plaisir:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
<?php
 
$headers = array('p2', 'p1', 'p0');
$cols    = array(
    array('0', '0', '0', '0', '1', '1', '1', '1'),
    array('0', '0', '1', '1', '0', '0', '1', '1'),
    array('0', '1', '0', '1', '0', '1', '0', '1')
);
 
 
class ColBuilder {
    var $cols;
    function ColBuilder($cols) {
        $this->cols = array();
        foreach($cols as $col) {
            $this->add($col);
        }
    }
    function add($col) {
        $the_col = array();
        $current = -1;
        foreach($col as $cell) {
            if ($current >= 0 && $the_col[$current]['content'] == $cell) {
                $the_col[$current]['nb']++;
            } else {
                $the_col[] = array('content' => $cell, 'nb' => 1);
                ++$current;
            }
        }
        $this->cols[] = $the_col;
    }
    function display() {
        $nb_cols = count($this->cols);
        if ($nb_cols > 0) {
            $next_index_for_col = array_fill(0, $nb_cols, 0);
            $rowspans_for_col = array_fill(0, $nb_cols, 0);
            $nb_rows = 0;
            foreach($this->cols[0] as $cell) {
                $nb_rows += $cell['nb'];
            }
            for($i = 0 ; $i < $nb_rows ; ++$i) {
                echo '<tr>';
                for($j = 0 ; $j < $nb_cols ; $j++) {
                    if ($next_index_for_col[$j] == $i) {
                        $cell = $this->cols[$j][$i - $rowspans_for_col[$j]];
                        echo '<td';
                        if ($cell['nb'] > 1) {
                            echo ' rowspan="', $cell['nb'], '" ';
                            $rowspans_for_col[$j] += $cell['nb'] - 1;
                        }
                        echo '>' , $cell['content'] , '</td>';
                        $next_index_for_col[$j] += $cell['nb'];
                    }
                }
                echo '</tr>'."\n";
            }
        }
    }
}
 
//--- Affichage
echo '<table border="1">';
 
echo '<tr>';
foreach($headers as $header) {
    echo '<th>' , $header , '</th>';
}
echo '</tr>';
 
$col_builder = new ColBuilder($cols);
$col_builder->display();
 
echo '</table>';
 
?>

Ce qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 
+----+----+----+
+    +    +  0 +
+    +  0 +----+
+    +    +  1 +
+  0 +----+----+
+    +    +  0 +
+    +  1 +----+
+    +    +  1 +
+----+----+----+
+    +    +  0 +
+    +  0 +----+
+    +    +  1 +
+  1 +----+----+
+    +    +  0 +
+    +  1 +----+
+    +    +  1 +
+----+----+----+

Maintenant à voir si ca s'applique dans ton cas et si ca change quelque chose au niveau perf. Mais bon quand on travaille, comme dans ta solution, avec un tableau de 10'000 lignes par 20 colonnes (soit 200'000 cellules) et qu'on fait une boucle sur chacune des cellules (dans l'exemple: 10 => 2'000'000 de boucles) il ne faut pas s'attendre à avoir des perfs du tonnerre...

[Mr N.]

Je viens de faire un test avec ce que je viens de proposer : 20 col x 5000 lignes => 9 secondes pour générer le contenu du tableau (construction+affichage)

Par contre, là où le bas blesse c'est que j'ai un Allowed memory size exhausted (32M) quand je demande 8000 lignes. Cela vient surement du fait que je ne travaille pas sur un résultat sql, mais sur un tableau en mémoire...

[schnito]

Merci bien Mr N !! En plus tu m'apprends des choses !

J'aimerais bien essayer de refaire ma fonction GetSqlValueRepeat avec un array_slice() et un array_count_value() ...

[Yogui]

Question bête en passant : si ton boss aime bien l'idée de la pagination pour l'affichage, j'imagine que tu vas l'utiliser. En ce cas, tu n'afficheras qu'un nombre limité de tuples sur chaque page : as-tu vraiment besoin des autres tuples (ceux que tu n'afficheras pas) ? Pourquoi ne pas utiliser LIMIT ?

[schnito]

Je vais utiliser LIMIT, je n'ai pas besoin des autres tuples, donc ca sera optimiser au taquet !

on va le faire parce que c bien utile, mais pour lui, c une facon de controurner mon probleme de performance, donc il veut qd meme que j'optimise mon algo ... relou !

[Mr N.]

Ce n'est pas juste une facon de contourner le problème. Ca a toute son utilité : afficher 200000 cellules à un utilisateur n'a strictement aucun intérêt.

[schnito]

Je sais ! et c pour ca qu'on va le faire ! en plus je connais bien ce systeme je l'ai deja fait !

mais il veut qd meme optimiser le traitement !

comme ca il a envie ...

[Yogui]

Il a la solution à ton optimisation, peut-être ? Il s'est déjà penché sur une boucle de 50000 itérations avec plein de données à manipuler ?
J'ai l'impression, sans avoir vérifié par moi-même, que Mr N. a pas mal planché dessus et qu'il n'a rien d'instantané non plus...

[schnito]

non il a pas la solution, il est sur d'autres dev il a pas le temps ... et je lui ai deja dit que c'etait normal qua ca soit aussi long ! avec un tableau aussi gros ... mais non !

Pour moi c de la perte de temps ...