把一个值绑定到一个参数
@param mixed $parameter
@param mixed $value
@param integer $dataType
@return boolean
495688
public function bindValue($parameter, $value, int $dataType = \PDO::PARAM_STR): bool
    {
        $this->binds[$parameter] = $value;
        return true;
    }
684046
public function bindValue(
        $parameter,
        $variable,
        $dataType = PDO::PARAM_STR
    )
    {
        return $this->bindParam($parameter, $variable, $dataType);
    }
1215773
public function bindParam($parameter, &$variable, int $dataType = \PDO::PARAM_STR, int $length = null, $driverOptions = null): bool
    {
        $this->binds[$parameter] = &$variable;
        return true;
    }
418447
public function setParam($id, $value, $data_type = NativePDO::PARAM_STR)
    {
        if (!$this->bindValue($id, $value, $data_type)) {
            throw new PDOException("Błąd podczas bindowania parametru '$id' o wartości '$value'", PDOException::CODEBIND);
        }

        return $this;
    }
746097
public function setValue($value, $data = null)
    {
        // Define Value Property:
        
        $this->value = $value;
        
        // Determine Value Type:
        
        if (is_array($value)) {
            
            // Define from Array:
            
            foreach ($this->getViewports() as $viewport) {
                
                $field = $this->getViewportField($viewport);
                
                if (isset($value[$viewport])) {
                    $field->setValue($value[$viewport]);
                }
                
            }
            
        } elseif ($value instanceof DBViewports) {
            
            // Define from Field:
            
            foreach ($this->getViewports() as $viewport) {
                $this->getViewportField($viewport)->setValue($value->{$viewport});
            }
            
        }
        
        // Answer Receiver:
        
        return $this;
    }
873849
public function validate($value) {
        if(!is_string($value)) {
            throw new DataType('value', 'string', $value);
        }
        
        if(!password_verify($value, $this->hash)) {
            return new ValidationResult(false, 'Wrong password');
        }        
        return new ValidationResult(true);
    }
421547
public function bindValue($parameter, $value, $type = \PDO::PARAM_STR)
    {
        list($value, $type) = TypeUtility::convertToDatabase($value, $type, $this->connection->getPlatform());

        return $this->getDriverStatement()->bindValue($parameter, $value, $type);
    }
1022503
public function parameterTypeCheck($param, string $type = 'string'): bool
    {
        $type = 'is_'.$type;

        return (bool) ($type($param) && ! empty($param));
    }
1012026
public function bindValue($column, $value, $type = 'string')
    {
        if ($type === null) {
            $type = 'string';
        }
        if (!ctype_digit($type)) {
            list($value, $type) = $this->cast($value, $type);
        }
        if ($type == PDO::PARAM_LOB) {
            $this->_statement->bindParam($column, $value, $type, 0, PDO::SQLSRV_ENCODING_BINARY);
        } else {
            $this->_statement->bindValue($column, $value, $type);
        }
    }
345274
protected function process($value, string $type)
    {
        if ($type === 'integer') {
            return (int) $value;
        }

        if ($type === 'float') {
            return (float) $value;
        }

        if ($type === 'boolean') {
            return (bool) $value;
        }

        return (string) $value;
    }
662575
public function bindValue($param, $value, $type = \PDO::PARAM_STR)
    {
        $this->statement->bindValue($param, $value, $type);
        return $this;
    }
735057
public function filterByDataType($data_type)
    {
        $callback = function (BindingInterface $binding, $key) use ($data_type) {
            switch ($data_type) {
                case PDO::PARAM_BOOL:
                    return $binding->isBoolean();
                case PDO::PARAM_NULL:
                    return $binding->isNull();
                case PDO::PARAM_INT:
                    return $binding->isInteger();
                case PDO::PARAM_STR:
                    return $binding->isString();
                case PDO::PARAM_LOB:
                    return $binding->isLargeObject();
                case PDO::PARAM_STMT:
                    return $binding->isStatement();
                case PDO::PARAM_INPUT_OUTPUT:
                    return $binding->isInputOutput();
            }
        };

        return $this->filter($callback);
    }
59965
public function setValue($value, $type = null)
    {
        $this->value = $value;
        $this->type  = $type ?: ParameterTypeInferer::inferType($value);
    }
5120
private function isValidType($value): bool
    {
        if ($this->type instanceof DataType) {
            return $this->type->isTheTypeOf($value);
        }

        return true;
    }
471434
private function bind($key, $value, $bindDataType)
    {
        $this->sqlQuery->bindValue($key, $value, $bindDataType);
    }
268151
public function bindValue($parameter, $value, $data_type = PDO::PARAM_STR)
	{
		$this->bindValues[$parameter] = array($parameter, $value, $data_type);
	}
445009
public static function isTypeOf($value, $type) {
        switch ($type) {
            case self::ARGUMENT_ARRAY:
                ArrayHelper::isArray($value);
                break;
            case self::ARGUMENT_BOOLEAN:
                BooleanHelper::isBoolean($value);
                break;
            case self::ARGUMENT_DATE:
                DateTimeHelper::isDate($value);
                break;
            case self::ARGUMENT_DOUBLE:
                DoubleHelper::isDouble($value);
                break;
            case self::ARGUMENT_FLOAT:
                FloatHelper::isFloat($value);
                break;
            case self::ARGUMENT_INTEGER:
                IntegerHelper::isInteger($value);
                break;
            case self::ARGUMENT_NUMBER:
                NumberHelper::isNumber($value);
                break;
            case self::ARGUMENT_OBJECT:
                ObjectHelper::isObject($value);
                break;
            case self::ARGUMENT_RESOURCE:
                ResourceHelper::isResource($value);
                break;
            case self::ARGUMENT_STRING:
                StringHelper::isString($value);
                break;
            case self::ARGUMENT_TIMESTAMP:
                TimestampHelper::isTimestamp($value);
                break;
            default:
                throw new IllegalArgumentException("The type \"" . $type . "\" is not implemented");
        }
        return true;
    }