Acortamiento del código, ORDER BY y SWITCH

¿Puedes ayudarme con la reducción del código? El punto es que quiero obtener datos de la base de datos en orden diferente según el $ T dado. ¿Alguna idea?

public function rewriteQuery($T){

switch ($T) {

    case 0:
        $query="SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD(id,1,2,3,4,5,6)";  
        break;
     case 1:
        $query="SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD(id,2,3,4,5,6,1)";  
        break;
     case 2:
        $query="SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD(id,3,4,5,6,1,2)";    
        break;
     case 3:
       $query="SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD(id,4,5,6,1,2,3)";  
        break;
     case 4:
      $query="SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD(id,5,6,1,2,3,4)";  
        break;
    default:
       $query="SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD(id,6,1,2,3,4,5)";  
    break;

    }        

  return $query;             

} 
0

5 Respuestas

Bueno, si quisieras ser particularmente horrible, podrías calcular todo:

public function rewriteQuery($T){
  $num_cols = 6;
 //Build a naughty little array to pick numbers from.
  $numbers = array_merge(range(1, $num_cols, 1), range(1, $num_cols, 1));
 //Pick the section from the array corresponding to our $T
  $rotated = array_slice($numbers, $T, $num_cols);
 //Shove "id" on the front
  array_unshift($rotated, 'id');
 //Build a string
  $final_list = implode(", ", $rotated);
 //Build the SQL
  $query = "SELECT id, title FROM kshome WHERE del = 0 AND active = 1 ORDER BY FIELD($final_list)";
  return $query;
}

Pero francamente, honestamente, no creo que haya mucho mal con lo que estás haciendo. Separar la cadena de ordenamiento de la consulta principal, como lo sugieren otras respuestas, le evitará tener que cambiar una tonelada de líneas si su consulta principal cambia, lo cual es bueno.

La idea es encontrar un equilibrio feliz entre el código de copiar y pegar, que es difícil de mantener, y un código que es tan inteligente que no lo entenderá cuando regrese a él dentro de tres semanas. Y siempre me equivocaría del lado de la primera.

Con lo que quiero decir: no tomes en serio esta respuesta: es solo un ejemplo de lo lejos que puedes equivocarte en términos de legibilidad y mantenibilidad si vas demasiado lejos en el camino de "nunca debo repetirme vagamente" "

0
agregado

Otherthan eliminando la redundancia al construir la cadena de consulta, no veo mucho más que pueda acortarse:

public function rewriteQuery($T){

$query = "SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD";
switch ($T) {
    case 0:
        $query.="(id,1,2,3,4,5,6)";  
        break;
     case 1:
        $query.="(id,2,3,4,5,6,1)";  
        break;
     case 2:
        $query.="(id,3,4,5,6,1,2)";    
        break;
     case 3:
       $query.="(id,4,5,6,1,2,3)";  
        break;
     case 4:
      $query.="(id,5,6,1,2,3,4)";  
        break;
    default:
       $query.="(id,6,1,2,3,4,5)";  
    break;

    }        

  return $query;             
0
agregado
la concatenación de cadenas en PHP se realiza con el operador . , no + .
agregado el autor knittl, fuente
$ query. = "(id, 1,2,3,4,5,6)"; y no $ query + = "(id, 1,2,3,4,5 , 6) "; etc. etc. etc.
agregado el autor Funk Forty Niner, fuente
Además, esto => $ query = = debe ser $ query = tienes 2x ==
agregado el autor Funk Forty Niner, fuente
De nada. Claro, solo asegúrate de mantenerlo alejado de tu teclado ;-) Lo hice "una vez" jajaja. La palabra operativa aquí es una vez . Aclamaciones
agregado el autor Funk Forty Niner, fuente
gracias, hizo las correcciones. Creo que debería terminar mi primer café de la mañana primero - jaja.
agregado el autor Andrew - OpenGeoCode, fuente

Una forma de acortar esto sería crear una matriz que devuelva los campos para el pedido .

Algo como esto:

$order_by_array = array(
  0 => "(id,1,2,3,4,5,6)", 
  1 => "(id,2,3,4,5,6,1)", 
  2 => "(id,3,4,5,6,1,2)", 
  3 => "(id,4,5,6,1,2,3)", 
  4 => "(id,5,6,1,2,3,4)"
);

Entonces su función rewriteQuery ($ T) se puede volver a escribir como:

public function rewriteQuery($T){
  $order_by = "(id,6,1,2,3,4,5)";//Default
  if (array_key_exists($T, $order_by_array)) {
    $order_by = $order_by_array[$T];
  }

  $query = "SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD{$order_by}";
  ...
}
0
agregado
De nada. Comentario borrado. aplausos ;-)
agregado el autor Funk Forty Niner, fuente
@ Fred-ii-, Ups, gracias por captar eso. Mezcla de tipo copiar/pegar ... :)
agregado el autor vee, fuente

Aunque preferiría las otras respuestas en caso de que su pedido sea reparado, aquí hay una solución más flexible:

function rewriteQuery($T) {
    $query = "SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD(id,";
    $order = array("1", "2", "3", "4", "5", "6");

    if($T < count($order)) {
        for($i = $T, $end = false;;$i++) {
            if($i == count($order)) {
                $i = 0;
                $end = true;
            }

            if($end && $i == $T) {
                break;
            }

            $query .= $order[$i] . ",";
        }

        $query = substr($query, 0, -1) . ")";

        return $query;
    } else {
        return "ERROR";
    }
}

$index = 5;

echo rewriteQuery($index);

Consulte el PHPfiddle .

Básicamente debe darse cuenta de que su $ T no es más que el índice desde el que desea comenzar su pedido (dado su pedido como una matriz). Una vez que te hayas dado cuenta de esto, puedes implementar la lógica:
con $ T como inicio, caminamos por la matriz hasta llegar al final, luego establecemos $ i en cero y activamos una condición-final para no ejecutar un ciclo infinito. $ i continuará aumentando de nuevo hasta que llegue a $ T y luego abandone el bucle. Todo lo que queda es deshacerse de los finales, . Simplemente lo reemplazo con un ) para completar la consulta.

0
agregado

Ok, sé que querías que el código fuera corto, pero en caso de que haya una llamada para un gran número de conmutadores, puedes probar un bucle en lugar de arreglos manuales ya que tu orden tiene un buen patrón.

public function rewriteQuery($T)
{
    $query = "SELECT id, title FROM kshome WHERE del=0 AND active=1 ORDER BY FIELD";
    $fieldOrder =" (id, ";

    $j = $T;
    $i=1;

    if($j > 0 && $j < 5)   //or whatever you wish
    {   
        while(1)
        {  //replace 6 (below) by whatever your limit is
            $fieldOrder .= ($j % 6) + 1;

            if($i < 6)
                $fieldOrder .= ", ";
            else
                break;

            $j++; $i++;
        }

    }
    else
    {   $fieldOrder .= "6, 1, 2, 3, 4, 5"; 
       //or maybe a loop again! :-D
    }
    $fieldOrder .= " )";
    return($query.$fieldOrder);
}
0
agregado
PHP - Comunidad española
PHP - Comunidad española
6 de los participantes

En este grupo hablamos de PHP. Partner: es.switch-case.com