public function testDecode()
{
$db = $this->getDb();
$adapter = new SqliteTypeAdapter($db);
$this->assertNull($adapter->decode(DataType::integer(), null));
$this->assertSame(15, $adapter->decode(DataType::integer(), '15'));
$this->assertSame(33.0, $adapter->decode(DataType::float(), 33));
$this->assertSame(true, $adapter->decode(DataType::boolean(), 1));
$this->assertSame(false, $adapter->decode(DataType::boolean(), 0));
$this->assertSame(4242, $adapter->decode(DataType::date(), 4242));
$this->assertSame(4242, $adapter->decode(DataType::dateTime(), 4242));
$this->assertSame('foo bar baz', $adapter->decode(DataType::string(), 'foo bar baz'));
$this->assertSame([], $adapter->decode(DataType::object(), '[]'));
}
public function testDecode()
{
$db = $this->getDb();
$adapter = new PostgresqlTypeAdapter($db);
$this->assertNull($adapter->decode(DataType::integer(), null));
$this->assertSame(15, $adapter->decode(DataType::integer(), '15'));
$this->assertSame(33.0, $adapter->decode(DataType::float(), 33));
$this->assertSame(true, $adapter->decode(DataType::boolean(), 1));
$this->assertSame(false, $adapter->decode(DataType::boolean(), 0));
$time = time();
$encoded = $adapter->encode(DataType::dateTime(), $time);
$this->assertTrue(preg_match('/^"(\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2})"$/', $encoded, $matches) === 1);
$this->assertEquals($time, $adapter->decode(DataType::dateTime(), $matches[1]));
$this->assertSame('foo bar baz', $adapter->decode(DataType::string(), 'foo bar baz'));
$this->assertSame([], $adapter->decode(DataType::object(), '[]'));
}
public function testInstance()
{
$record = [];
$quoter = $this->getMockBuilder('Jivoo\\Data\\Query\\Expression\\Quoter')->getMock();
$quoter->method('quoteLiteral')->willReturnCallback(function ($type, $value) {
return $value ? 'true' : 'false';
});
$prefix = new Prefix('not', new Literal(DataType::boolean(), true));
$this->assertFalse($prefix->__invoke($record));
$this->assertEquals('not true', $prefix->toString($quoter));
$prefix = new Prefix('not', new Infix(new Literal(DataType::boolean(), true), 'and', new Literal(DataType::boolean(), false)));
$this->assertTrue($prefix->__invoke($record));
$this->assertEquals('not (true and false)', $prefix->toString($quoter));
$prefix = new Prefix('!', new Literal(DataType::boolean(), true));
$this->assertThrows('PHPUnit_Framework_Error', function () use($prefix, $record) {
$prefix($record);
});
}
/**
* Substitute and encode variables in an expression.
*
* Placeholders (see also {@see DataType::fromPlaceHolder()}:
* <code>
* true // Boolean true
* false // Boolean false
* {AnyModelName} // A model name
* [anyFieldName] // A column/field name
* "any string" // A string
* ? // Any scalar value.
* %e %expr %expression // A subexpression (instance of {@see Expression})
* %m %model // A table/model object or name
* %c %column %field // A column/field name
* %_ // A placeholder placeholder, can also be a type, e.g. where(..., 'id = %_', $type, $value)
* %i %int %integer // An integer value
* %f %float // A floating point value
* %s %str %string // A string
* %t $text // Text
* %b %bool %boolean // A boolean value
* %date // A date value
* %d %datetime // A date/time value
* %n %bin %binary // A binary object
* %AnyEnumClassName // An enum value of that class
* %anyPlaceholder() // A tuple of values
* </code>
*
* @param string|Condition $format Expression format, use placeholders instead of values.
* @param mixed[] $vars List of values to replace placeholders with.
* @param Quoter $quoter Quoter object for quoting identifieres and literals.
* @return string The interpolated expression.
*/
public static function interpolate($format, $vars, Quoter $quoter)
{
if ($format instanceof self) {
return $format->toString($quoter);
}
assume(is_string($format));
$boolean = DataType::boolean();
$true = $quoter->quoteLiteral($boolean, true);
$false = $quoter->quoteLiteral($boolean, false);
$format = preg_replace('/\\btrue\\b/i', $true, $format);
$format = preg_replace('/\\bfalse\\b/i', $false, $format);
$string = DataType::text();
$format = preg_replace_callback('/"((?:[^"\\\\]|\\\\.)*)"|\\{(.+?)\\}|\\[(.+?)\\]/', function ($matches) use($quoter, $string) {
if (isset($matches[3])) {
return $quoter->quoteField($matches[3]);
} else {
if (isset($matches[2])) {
return $quoter->quoteModel($matches[2]);
} else {
return $quoter->quoteLiteral($string, stripslashes($matches[1]));
}
}
}, $format);
$i = 0;
return preg_replace_callback('/((\\?)|%([a-z_\\\\]+))(\\(\\))?/i', function ($matches) use($vars, &$i, $quoter) {
$value = $vars[$i];
$i++;
$type = null;
if (isset($matches[3])) {
if ($matches[3] == '_') {
if (!is_string($value)) {
assume($value instanceof DataType);
$value = $value->placeholder;
}
$matches[3] = ltrim($value, '%');
$value = $vars[$i];
$i++;
}
if ($matches[3] == 'e' or $matches[3] == 'expr' or $matches[3] == 'expression') {
assume($value instanceof Expression);
return '(' . $value->toString($quoter) . ')';
}
if ($matches[3] == 'm' or $matches[3] == 'model') {
if (!is_string($value)) {
assume($value instanceof Model);
$value = $value->getName();
}
return $quoter->quoteModel($value);
}
if ($matches[3] == 'c' or $matches[3] == 'column' or $matches[3] == 'field') {
assume(is_string($value));
return $quoter->quoteField($value);
}
if ($matches[3] != '()') {
$type = DataType::fromPlaceholder($matches[3]);
}
}
if (!isset($type)) {
$type = DataType::detectType($value);
}
if (isset($matches[4]) or isset($matches[3]) and $matches[3] == '()') {
assume(is_array($value));
foreach ($value as $key => $v) {
$value[$key] = $quoter->quoteLiteral($type, $v);
}
return '(' . implode(', ', $value) . ')';
}
return $quoter->quoteLiteral($type, $value);
}, $format);
}
/**
*
* @param string $expression
* @return ParseInput
*/
public static function lex($expression, $vars = array())
{
$lexer = new RegexLexer(true, 'i');
$lexer->is = 'is';
$lexer->not = 'not';
$lexer->bool = 'true|false';
$lexer->null = 'null';
$lexer->operator = 'like|in|!=|<>|>=|<=|!<|!>|=|<|>|and|or';
$lexer->dot = '\\.';
$lexer->name = '[a-z][a-z0-9]*';
$lexer->model = '\\{(.+?)\\}';
$lexer->modelPlaceholder = '%(model|m)';
$lexer->field = '\\[(.+?)\\]';
$lexer->fieldPlaceholder = '%(column|field|c)';
$lexer->number = '-?(0|[1-9]\\d*)(\\.\\d+)?([eE][+-]?\\d+)?';
$lexer->string = '"((?:[^"\\\\]|\\\\.)*)"';
$lexer->placeholder = '((\\?)|%([a-z_\\\\]+))(\\(\\))?';
$lexer->map('model', function ($value, $matches) {
return $matches[1];
});
$lexer->map('field', function ($value, $matches) {
return $matches[1];
});
$lexer->map('number', function ($value) {
if (strpos($value, '.') !== false or stripos($value, 'e') !== false) {
return new Literal(DataType::float(), floatval($value));
} else {
return new Literal(DataType::integer(), intval($value));
}
});
$lexer->mapType('number', 'literal');
$lexer->map('string', function ($value, $matches) {
return new Literal(DataType::text(), stripslashes($matches[1]));
});
$lexer->mapType('string', 'literal');
$lexer->map('bool', function ($value) {
return new Literal(DataType::boolean(), strtolower($value) == 'true');
});
$lexer->mapType('bool', 'literal');
$lexer->map('model', function ($value, $matches) {
return $matches[1];
});
$lexer->map('field', function ($value, $matches) {
return $matches[1];
});
$i = 0;
$lexer->map('modelPlaceholder', function ($value, $matches) use(&$i, $vars) {
$value = $vars[$i];
$i++;
if (!is_string($value)) {
Assume::that($value instanceof Model);
$value = $value->getName();
}
return $value;
});
$lexer->mapType('modelPlaceholder', 'model');
$lexer->map('fieldPlaceholder', function ($value, $matches) use(&$i, $vars) {
$value = $vars[$i];
$i++;
Assume::that(is_string($value));
return $value;
});
$lexer->mapType('fieldPlaceholder', 'field');
$lexer->map('placeholder', function ($value, $matches) use(&$i, $vars) {
$value = $vars[$i];
$i++;
$type = null;
if (isset($matches[3])) {
if ($matches[3] == '_') {
if (!is_string($value)) {
Assume::that($value instanceof DataType);
$value = $value->placeholder;
}
$matches[3] = ltrim($value, '%');
$value = $vars[$i];
$i++;
}
if ($matches[3] == 'e' or $matches[3] == 'expr' or $matches[3] == 'expression') {
Assume::that($value instanceof Expression);
return $value;
}
if ($matches[3] != '()') {
$type = DataType::fromPlaceholder($matches[3]);
}
}
if (!isset($type)) {
$type = DataType::detectType($value);
}
if (isset($matches[4]) or isset($matches[3]) and $matches[3] == '()') {
Assume::isArray($value);
foreach ($value as $key => $v) {
$value[$key] = $v;
}
return new ArrayLiteral($type, $value);
}
return new Literal($type, $value);
});
$lexer->mapType('placeholder', 'literal');
return new ParseInput($lexer($expression));
}
/**
* Convert output of SHOW COLUMN to DataType.
*
* @param array $row
* Row result.
* @throws TypeException If type unsupported.
* @return DataType The type.
*/
private function toDataType($row)
{
$null = $row['is_nullable'] != 'NO';
$default = null;
if (isset($row['column_default'])) {
$default = $row['column_default'];
}
$type = $row['data_type'];
if (strpos($type, 'int') !== false) {
$intFlags = 0;
if (preg_match('/^nextval\\(/', $default) === 1) {
$intFlags = DataType::SERIAL;
$default = null;
} elseif (isset($default)) {
$default = intval($default);
}
if (strpos($type, 'bigint') !== false) {
return DataType::integer($intFlags | DataType::BIG, $null, $default);
}
if (strpos($type, 'smallint') !== false) {
return DataType::integer($intFlags | DataType::SMALL, $null, $default);
}
return DataType::integer($intFlags, $null, $default);
}
if (strpos($type, 'double') !== false) {
return DataType::float($null, isset($default) ? floatval($default) : null);
}
if (strpos($type, 'bool') !== false) {
return DataType::boolean($null, isset($default) ? boolval($default) : null);
}
if (preg_match("/^'(.*)'::[a-z ]+\$/", $default, $matches) === 1) {
$default = $matches[1];
} else {
$default = null;
}
if (strpos($type, 'character') !== false) {
$length = intval($row['character_maximum_length']);
return DataType::string($length, $null, $default);
}
if (strpos($type, 'date') !== false) {
return DataType::date($null, isset($default) ? strtotime($default . ' UTC') : null);
}
if (strpos($type, 'timestamp') !== false) {
return DataType::dateTime($null, isset($default) ? strtotime($default . ' UTC') : null);
}
if (strpos($type, 'text') !== false) {
return DataType::text($null, $default);
}
throw new TypeException('Unsupported PostgreSQL type "' . $row['data_type'] . '" for column: ' . $row['column_name']);
}