CakePHP 3.0 -> Entre l'état à trouver

Est-il possible de faire un "ENTRE les deux ? ET ?" où l'état COMME dans cakephp 2.5?
Dans cakephp 2.5-je écrire quelque chose comme

'conditions' => ['start_date BETWEEN ? AND ?' => ['2014-01-01', '2014-12-32']]

comment puis-je migrer?

en outre, je voudrais écrire quelque chose comme

'conditions' => [ '? BETWEEN start_date AND end_date'] => '2014-03-31']

OriginalL'auteur mdlouhy | 2014-10-17

27

Expressions

Entre l'expression sont pris en charge hors de la boîte, mais ils prennent uniquement en charge le premier cas, sans autre tripoter:
```
$Query = $Table
    ->find()
    ->where(function($exp) {
        return $exp->between('start_date', '2014-01-01', '2014-12-32', 'date');
    });
```
Si vous voulais gérer le second cas, par la entre la méthode, alors vous auriez à passer toutes les valeurs des expressions, ce qui peut facilement se tromper, car ils ne seront pas soumis à échapper à/de liaison de paramètre dans ce cas, vous devriez le faire sur votre propre (ce qui est quelque chose, mais recommandé! Voir les consignes de sécurité dans le manuel de PDO::quote()), quelque chose le long des lignes de:
```
use Cake\Database\Expression\IdentifierExpression;
use Cake\Database\Expression\QueryExpression;
use Cake\ORM\Query;

//...

$Query = $Table
    ->find()
    ->where(function(QueryExpression $exp, Query $query) {
        return $exp->between(
            $query->newExpr(
                $query->connection()->driver()->quote(
                    '2014-03-31',
                    \PDO::PARAM_STR
                )
            ),
            new IdentifierExpression('start_date'),
            new IdentifierExpression('end_date')
        );
    });
```
Qui pourraient se sentir un peu gênant pour une telle base de l'expression SQL qui est pris en charge par tous les dialectes SQL que CakePHP est livré avec, donc vous pouvez avoir une raison d'utiliser ici la valeur bindig à la place.

Il convient toutefois de noter que les expressions sont généralement le meilleur choix quand il s'agit de traverser le dialecte de soutien, car ils peuvent être (plus ou moins) facilement transformés au moment de la compilation, voir les implémentations de SqlDialectTrait::_expressionTranslators(). Aussi les expressions généralement prise en charge automatique des identificateurs.

Valeur contraignante

Via le manuel de la valeur de la liaison, vous pouvez très bien créer quelque chose que vous aimez. Il convient toutefois de noter que, chaque fois que possible, vous devriez utiliser des expressions au lieu de cela, car ils sont plus faciles à porter, qui se trouve hors de la boîte pour quelques expressions déjà.
```
$Query = $Table
    ->find()
    ->where([
        'start_date BETWEEN :start AND :end'
    ])
    ->bind(':start', '2014-01-01', 'date')
    ->bind(':end',   '2014-12-31', 'date');
```
De cette façon, le deuxième cas peut être résolu très facilement, comme:
```
$Query = $Table
    ->find()
    ->where([
        ':date BETWEEN start_date AND end_date'
    ])
    ->bind(':date', '2014-03-31', 'date');
```
Un mélange des deux (la plus sûre et la plus compatible avec une approche

Il est également possible de mélanger les deux, c'est à dire utiliser une expression qui rend l'utilisation de liaisons personnalisées, quelque chose le long des lignes de ce:
```
use Cake\Database\Expression\IdentifierExpression;
use Cake\Database\Expression\QueryExpression;
use Cake\ORM\Query;

//...

$Query = $Table
    ->find()
    ->where(function(QueryExpression $exp, Query $query) {
        return $exp->between(
            $query->newExpr(':date'),
            new IdentifierExpression('start_date'),
            new IdentifierExpression('end_date')
        );
    })
    ->bind(':date', '2014-03-31', 'date');
```
Cette façon, vous pouvez gérer le second cas, en utilisant éventuellement portable expressions, et ne pas avoir à vous soucier de citant/s'échapper d'entrée de données et les identifiants manuellement.

Voir aussi
- Livre de cuisine > Base de données Access & ORM > Query Builder > Avancé des Conditions
- API > \Cake\Database\Query::bind()
~~Actuellement il semble y avoir seulement deux options.~~ Le cœur prend désormais en charge cette sortie de la boîte, ce qui suit est juste conservé pour référence.

Valeur de liaison (via la base de données du générateur de requête)

Pour l'instant, l'ORM générateur de requêtes (Cake\ORM\Query), celui qui est en train d'être récupéré lors de l'invocation par exemple find() sur un objet de la table, ne supporte pas la valeur de liaison

https://github.com/cakephp/cakephp/issues/4926

Donc, pour être capable d'utiliser les liaisons que vous auriez à utiliser la base de données du générateur de requête (Cake\Database\Query), qui peut par exemple être récupéré via Connexion::nouveaurequête().

Voici un exemple:
```
$conn = ConnectionManager::get('default');

$Query = $conn->newQuery(); 
$Query
    ->select('*')
    ->from('table_name')
    ->where([
        'start_date BETWEEN :start AND :end'
    ])
    ->bind(':start', new \DateTime('2014-01-01'), 'date')
    ->bind(':end',   new \DateTime('2014-12-31'), 'date');

debug($Query->execute()->fetchAll());
```
Cela aurait pour conséquence une requête similaire à ce
```
SELECT 
    *
FROM
    table_name
WHERE
    start_date BETWEEN '2014-01-01' AND '2014-12-31'
```
Une expression personnalisée classe

Une autre option serait une coutume expression classe qui génère le SQL appropriée des extraits. Voici un exemple.

Les noms de colonnes doivent être enveloppées dans de l'identificateur de l'expression des objets afin de leur être auto cité (dans le cas de l'auto de devis est activé), la clé > tableau de valeur de la syntaxe pour la liaison des valeurs, où la clé du tableau est la valeur réelle, et les valeurs du tableau est le type de données.

Veuillez noter qu'il n'est pas sûr de passer directement la saisie de l'utilisateur pour les noms de colonne, comme ils ne sont pas échappé! Utiliser une liste blanche ou similaire à assurez-vous que le nom de la colonne est sûr à utiliser!

Champ entre les valeurs
```
use App\Database\Expression\BetweenComparison;
use Cake\Database\Expression\IdentifierExpression;

//...

$between = new BetweenComparison(
    new IdentifierExpression('created'),
    ['2014-01-01' => 'date'],
    ['2014-12-31' => 'date']
);

$TableName = TableRegistry::get('TableName');
$Query = $TableName
    ->find()
    ->where($between);

debug($Query->execute()->fetchAll());
```
Ce serait de générer une requête similaire à celui ci-dessus.

Valeur entre les champs
```
use App\Database\Expression\BetweenComparison;
use Cake\Database\Expression\IdentifierExpression;

//...

$between = new BetweenComparison(
    ['2014-03-31' => 'date'],
    new IdentifierExpression('start_date'),
    new IdentifierExpression('end_date')
);

$TableName = TableRegistry::get('TableName');
$Query = $TableName
    ->find()
    ->where($between);

debug($Query->execute()->fetchAll()); 
```
Ce, d'autre part, suite à une requête similaire à ce
```
SELECT 
    *
FROM
    table_name
WHERE
    '2014-03-31' BETWEEN start_date AND end_date
```
L'expression de la classe
```
namespace App\Database\Expression;
use Cake\Database\ExpressionInterface;
use Cake\Database\ValueBinder;
class BetweenComparison implements ExpressionInterface {
protected $_field;
protected $_valueA;
protected $_valueB;
public function __construct($field, $valueA, $valueB) {
$this->_field = $field;
$this->_valueA = $valueA;
$this->_valueB = $valueB;
}
public function sql(ValueBinder $generator) {
$field  = $this->_compilePart($this->_field,  $generator);
$valueA = $this->_compilePart($this->_valueA, $generator);
$valueB = $this->_compilePart($this->_valueB, $generator);
return sprintf('%s BETWEEN %s AND %s', $field, $valueA, $valueB);
}
public function traverse(callable $callable) {
$this->_traversePart($this->_field,  $callable);
$this->_traversePart($this->_valueA, $callable);
$this->_traversePart($this->_valueB, $callable);
}
protected function _bindValue($value, $generator, $type) {
$placeholder = $generator->placeholder('c');
$generator->bind($placeholder, $value, $type);
return $placeholder;
}
protected function _compilePart($value, $generator) {
if ($value instanceof ExpressionInterface) {
return $value->sql($generator);
} else if(is_array($value)) {
return $this->_bindValue(key($value), $generator, current($value));
}
return $value;
}
protected function _traversePart($value, callable $callable) {
if ($value instanceof ExpressionInterface) {
$callable($value);
$value->traverse($callable);
}
}
}
```
Je suppose que ce n'est pas la question. La question est basée sur cakephp 2.5 alors, comment faire quelque chose comme ceci dans cakephp 3: 'conditions' => ['date_debut ENTRE les deux ? ET ?' => ['2014-01-01', '2014-12-32']] en raison de son importante que sa part de l'état, de sorte que nous pouvons l'a écrit ainsi sur la pagination. $this->Model->find('all', ['conditions' => $conditions]) ou $this->paginate = ['conditions' => $conditions]
Je n'ai aucune idée de ce que vous essayez de dire.
Je veux dire que j'ai beaucoup de code qui ressemble à ceci sur la pagination $this->paginate = ['conditions' => $conditions] $conditions de tableau et il fonctionne sur cakephp 3 à l'exception de la entre les conditions. Alors, comment faire quelque chose comme ceci: 'conditions' => ['date_debut ENTRE les deux ? ET ?' => ['2014-01-01', '2014-12-32']] sur un tableau des conditions de
ses bizarre mais la réponse ci-dessous me semble bon. donc aussi simple que cela, 'conditions' => ['date_debut ENTRE "2014-01-01" ET "2014-12-32"']
Les techniques présentées dans ma réponse sont ceux que vous devez utiliser lorsque vous traitez avec la saisie de l'utilisateur (qui doit être considéré comme dangereux), et/ou lorsque vous avez besoin de l'expression à transformables plus tard (par exemple pour SQL personnalisée dialectes). Si vous aviez réellement codé en dur de la chaîne de valeurs, puis la construction d'un simple code SQL de la chaîne est une solution possible. Cela étant dit, pour des conditions complexes, vous pouvez passer une fermeture à la conditions option, tout comme where() l'accepte, ou vous pouvez construire la requête, vous-même et de le passer à la paginator (il accepte les tables ainsi que des objets de requête).

OriginalL'auteur ndm

Vous pouvez utiliser l'une des 2 méthodes suivantes.

Méthode 1 :

$start_date = '2014-01-01 00:00:00';
$end_date = '2014-12-31 23:59:59';
$query = $this->Table->find('all')
->where(function ($exp, $q) use($start_date,$end_date) {
return $exp->between('start_date', $start_date, $end_date);
});
$result = $query->toArray();

Méthode 2:

$start_date = '2014-01-01 00:00:00';
$end_date = '2014-12-31 23:59:59';
$query = $this->Table->find('all')
->where([
'start_date BETWEEN :start AND :end'
])
->bind(':start', new \DateTime($start_date), 'datetime')
->bind(':end',   new \DateTime($end_date), 'datetime');
$result = $query->toArray();

OriginalL'auteur monsur.hoq

-3

Bonjour les gars, merci d'utiliser cette requête pour obtenir des données sur la base de la gamme de valeur
```
    $query = $this->Leads->find('all', 
array('conditions'=>array('postcode BETWEEN '.$postcodeFrom.' and'.$postcodeTo.''), 'recursive'=>-1));
debug($query);
print_r($query->toArray());
```
pourriez-vous format de la requête un peu?
Non, s'il vous plaît, tout le monde NE PAS utiliser ce! C'est une vulnérabilité d'injection SQL - jamais de la confiance de l'utilisateur des données et de les inclure directement dans les requêtes, ce qui est effectivement ce que cet exemple est en train de faire, comme unique valeur des entrées dans des conditions, tout comme la gauche des valeurs de key => value entrées, ne sont pas l'objet de la liaison, au contraire, ces cordes seront insérés dans la requête telle qu'elle est!

OriginalL'auteur Aditya Dhanraj

Vous devez vous connecter pour publier un commentaire.

Expressions

Valeur contraignante

Un mélange des deux (la plus sûre et la plus compatible avec une approche

Voir aussi

Valeur de liaison (via la base de données du générateur de requête)

Une expression personnalisée classe

Champ entre les valeurs

Valeur entre les champs

L'expression de la classe