public function convertSqlToJob(SQLTokenIterator $tokens)
{
$tokens->seekTokenNum(SqlToken::T_UPDATE());
if ($tokens->getCurrentTokenNumber() !== SqlToken::T_UPDATE()) {
throw new ErrorException("Tried to parse update statement when token-iterator does not point to T_UPDATE!");
}
$dataChange = new UpdateDataChange();
$updateJob = new UpdateStatement();
if ($tokens->seekTokenNum(SqlToken::T_LOW_PRIORITY())) {
$updateJob->setIsLowPriority(true);
}
if ($tokens->seekTokenNum(SqlToken::T_IGNORE())) {
$updateJob->setDoIgnoreErrors(true);
}
do {
if (!$this->tableParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing table specifier in UPDATE statement!", $tokens);
}
$updateJob->addTable($this->tableParser->convertSqlToJob($tokens));
} while ($tokens->seekTokenText(','));
if (!$tokens->seekTokenNum(SqlToken::T_SET())) {
throw new MalformedSqlException("Missing SET after table specifier in UPDATE statement!", $tokens);
}
do {
if (!$this->columnParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing column specifier for SET part in UPDATE statement!", $tokens);
}
$dataChange->setColumn($this->columnParser->convertSqlToJob($tokens));
if (!$tokens->seekTokenText('=')) {
throw new MalformedSqlException("Missing '=' on SET part in UPDATE statement!", $tokens);
}
if (!$this->valueParser->canParseTokens($tokens)) {
throw new MalformedSqlException("MIssing valid value on SET part in UPDATE statement!", $tokens);
}
$dataChange->setValue($this->valueParser->convertSqlToJob($tokens));
$updateJob->addDataChange(clone $dataChange);
} while ($tokens->seekTokenText(','));
if ($tokens->seekTokenNum(SqlToken::T_WHERE())) {
if (!$this->valueParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing condition for WHERE clause in UPDATE statement!", $tokens);
}
$updateJob->setCondition($this->valueParser->convertSqlToJob($tokens));
}
if ($tokens->seekTokenNum(SqlToken::T_ORDER())) {
if (!$tokens->seekTokenNum(SqlToken::T_BY())) {
throw new MalformedSqlException("Missing BY after ORDER on UPDATE statement!", $tokens);
}
if (!$this->columnParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing column specifier for ORDER BY part on UPDATE statement!", $tokens);
}
$updateJob->setOrderColumn($this->columnParser->convertSqlToJob($tokens));
if ($tokens->seekTokenNum(SqlToken::T_DESC())) {
$updateJob->setOrderDirection(SqlToken::T_DESC());
} elseif ($tokens->seekTokenNum(SqlToken::T_ASC())) {
$updateJob->setOrderDirection(SqlToken::T_ASC());
}
}
if ($tokens->seekTokenNum(SqlToken::T_LIMIT())) {
if (!$tokens->seekTokenNum(T_NUM_STRING)) {
throw new MalformedSqlException("Missing offset number for LIMIT part in UPDATE statement!", $tokens);
}
$updateJob->setLimitOffset((int) $tokens->getCurrentTokenString());
if ($tokens->seekTokenText(',')) {
if (!$tokens->seekTokenNum(T_NUM_STRING)) {
throw new MalformedSqlException("Missing length number for LIMIT part in UPDATE statement!", $tokens);
}
$updateJob->setLimitRowCount((int) $tokens->getCurrentTokenString());
}
}
return $updateJob;
}
public function convertSqlToJob(SQLTokenIterator $tokens)
{
$tokens->seekTokenNum(SqlToken::T_INSERT());
if ($tokens->getCurrentTokenNumber() !== SqlToken::T_INSERT()) {
throw new ErrorException("Tried to parse INSERT statement when token-iterator is not at INSERT!");
}
$dataChange = new InsertDataChange();
$insertJob = new InsertStatement();
switch (true) {
case $tokens->seekTokenNum(SqlToken::T_LOW_PRIORITY()):
$insertJob->setPriority(Priority::LOW_PRIORITY());
break;
case $tokens->seekTokenNum(SqlToken::T_DELAYED()):
$insertJob->setPriority(Priority::DELAYED());
break;
case $tokens->seekTokenNum(SqlToken::T_HIGH_PRIORITY()):
$insertJob->setPriority(Priority::HIGH_PRIORITY());
break;
}
if ($tokens->seekTokenNum(SqlToken::T_IGNORE())) {
$insertJob->setDoIgnoreErrors(true);
}
if (!$tokens->seekTokenNum(SqlToken::T_INTO())) {
throw new MalformedSqlException("Missing INTO after INSERT for INSERT INTO statement!", $tokens);
}
if (!$this->tableParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing table-specifier for INSERT INTO statement!", $tokens);
}
$insertJob->setTable($this->tableParser->convertSqlToJob($tokens));
if ($tokens->seekTokenText('(')) {
do {
if (!$this->columnParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing valid column name in column selection for INSERT INTO statement!", $tokens);
}
$insertJob->addColumnSelection($this->columnParser->convertSqlToJob($tokens));
} while ($tokens->seekTokenText(','));
if (!$tokens->seekTokenText(')')) {
throw new MalformedSqlException("Missing closing parenthesis after column-selection for INSERT INTO statement!");
}
if ($tokens->seekTokenNum(SqlToken::T_VALUES())) {
do {
if (!$tokens->seekTokenText('(')) {
throw new MalformedSqlException("Missing begin parenthesis in value definiton for INSERT INTO statement!", $tokens);
}
$dataRow = array();
do {
switch (true) {
case $this->valueParser->canParseTokens($tokens):
$dataRow[] = $this->valueParser->convertSqlToJob($tokens);
break;
default:
throw new MalformedSqlException("Invalid value in value-defintion for INSERT INTO statement!", $tokens);
}
} while ($tokens->seekTokenText(','));
if (!$tokens->seekTokenText(')')) {
throw new MalformedSqlException("Missing ending parenthesis in value definiton for INSERT INTO statement!", $tokens);
}
$insertJob->addDataSourceValuesRow($dataRow);
} while ($tokens->seekTokenText(','));
} elseif ($this->selectParser->canParseTokens($tokens)) {
$insertJob->setDataSourceSelect($this->selectParser->convertSqlToJob($tokens));
} else {
throw new MalformedSqlException("Invalid data-source-definiton (VALUES or SELECT) in INSERT INTO statement!", $tokens);
}
} elseif ($tokens->seekTokenNum(SqlToken::T_SET())) {
do {
if (!$this->columnParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing column specifier for INSERT INTO SET statement!", $tokens);
}
$dataChange->setColumn($this->columnParser->convertSqlToJob($tokens));
if (!$tokens->seekTokenText('=')) {
throw new MalformedSqlException("Missing '=' in INSERT INTO SET statement!", $tokens);
}
switch (true) {
case $this->valueParser->canParseTokens($tokens):
$dataChange->setValue($this->valueParser->convertSqlToJob($tokens));
break;
default:
throw new MalformedSqlException("Invalid value for INSERT INTO SET statement!", $tokens);
}
$insertJob->addColumnSetValue(clone $dataChange);
} while ($tokens->seekTokenText(','));
} elseif ($this->selectParser->canParseTokens($tokens)) {
$insertJob->setDataSourceSelect($this->selectParser->convertSqlToJob($tokens));
} else {
throw new MalformedSqlException("Invalid column-selection for INSERT INTO statement!", $tokens);
}
if ($tokens->seekTokenNum(SqlToken::T_ON())) {
if (!$tokens->seekTokenNum(SqlToken::T_DUPLICATE())) {
throw new MalformedSqlException("Missing DUPLICATE in INSERT INTO ON DUPLICATE KEY UPDATE statement!", $tokens);
}
if (!$tokens->seekTokenNum(SqlToken::T_KEY())) {
throw new MalformedSqlException("Missing KEY in INSERT INTO ON DUPLICATE KEY UPDATE statement!", $tokens);
}
if (!$tokens->seekTokenNum(SqlToken::T_UPDATE())) {
throw new MalformedSqlException("Missing UPDATE in INSERT INTO ON DUPLICATE KEY UPDATE statement!", $tokens);
}
do {
if (!$this->columnParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing column specifier for INSERT INTO ON DUPLICATE KEY UPDATE statement!", $tokens);
}
$dataChange->setColumn($this->columnParser->convertSqlToJob($tokens));
if (!$tokens->seekTokenText('=')) {
throw new MalformedSqlException("Missing '=' in INSERT INTO ON DUPLICATE KEY UPDATE statement!", $tokens);
}
switch (true) {
case $valueParser->canParseTokens($tokens):
$dataChange->setValue($valueParser->convertSqlToJob($tokens));
break;
default:
throw new MalformedSqlException("Invalid value for INSERT INTO ON DUPLICATE KEY UPDATE statement!", $tokens);
}
$insertJob->addOnDuplicateDataChange(clone $dataChange);
} while ($tokens->seekTokenText(','));
}
return $insertJob;
}
public function convertSqlToJob(SQLTokenIterator $tokens)
{
$tokens->seekTokenNum(SqlToken::T_DELETE());
if ($tokens->getCurrentTokenNumber() !== SqlToken::T_DELETE()) {
throw new ErrorException("Tried to parse DELETE statement when token iterator is not at T_DELETE!");
}
$deleteJob = new DeleteStatement();
if ($tokens->seekTokenNum(SqlToken::T_LOW_PRIORITY())) {
$deleteJob->setIsLowPriority(true);
}
if ($tokens->seekTokenNum(SqlToken::T_QUICK())) {
$deleteJob->setIsQuick(true);
}
if ($tokens->seekTokenNum(SqlToken::T_IGNORE())) {
$deleteJob->setIsIgnore(true);
}
if ($tokens->seekTokenNum(SqlToken::T_FROM())) {
do {
if (!$this->tableParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing valid table specifier in DELETE statement!", $tokens);
}
$deleteJob->addDeleteTable($this->tableParser->convertSqlToJob($tokens));
if ($tokens->seekTokenText('.')) {
if (!$tokens->seekTokenText('*')) {
throw new MalformedSqlException("Only '*' allowed for column specification in DELETE statement!", $tokens);
}
}
} while ($tokens->seekTokenText(','));
if ($tokens->seekTokenNum(SqlToken::T_USING())) {
if (!$this->joinParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing valid JOIN definition after USING in DELETE statement!", $tokens);
}
$deleteJob->setJoinDefinition($this->joinParser->convertSqlToJob($tokens));
}
} else {
do {
if (!$this->tableParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing valid table specifier in DELETE statement!", $tokens);
}
$deleteJob->addDeleteTable($this->tableParser->convertSqlToJob($tokens));
if ($tokens->seekTokenText('.')) {
if (!$tokens->seekTokenText('*')) {
throw new MalformedSqlException("Only '*' allowed for column specification in DELETE statement!", $tokens);
}
}
} while ($tokens->seekTokenText(','));
if ($tokens->seekTokenNum(SqlToken::T_FROM())) {
if (!$this->joinParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing valid JOIN definition after FROM in DELETE statement!", $tokens);
}
$deleteJob->setJoinDefinition($this->joinParser->convertSqlToJob($tokens));
}
}
if ($tokens->seekTokenNum(SqlToken::T_WHERE())) {
if (!$this->valueParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing condition for WHERE clause in UPDATE statement!", $tokens);
}
$deleteJob->setCondition($this->valueParser->convertSqlToJob($tokens));
}
if ($tokens->seekTokenNum(SqlToken::T_ORDER())) {
if (!$tokens->seekTokenNum(SqlToken::T_BY())) {
throw new MalformedSqlException("Missing BY after ORDER on DELETE statement!", $tokens);
}
if (!$columnParser->canParseTokens($tokens)) {
throw new MalformedSqlException("Missing column specifier for ORDER BY part on DELETE statement!", $tokens);
}
$deleteJob->setOrderColumn($columnParser->convertSqlToJob($tokens));
if ($tokens->seekTokenNum(SqlToken::T_DESC())) {
$deleteJob->setOrderDirection(SqlToken::T_DESC());
} elseif ($tokens->seekTokenNum(SqlToken::T_ASC())) {
$deleteJob->setOrderDirection(SqlToken::T_ASC());
}
}
if ($tokens->seekTokenNum(SqlToken::T_LIMIT())) {
if (!$tokens->seekTokenNum(T_NUM_STRING)) {
throw new MalformedSqlException("Missing offset number for LIMIT part in DELETE statement!", $tokens);
}
$deleteJob->setLimitOffset((int) $tokens->getCurrentTokenString());
if ($tokens->seekTokenText(',')) {
if (!$tokens->seekTokenNum(T_NUM_STRING)) {
throw new MalformedSqlException("Missing length number for LIMIT part in DELETE statement!", $tokens);
}
$deleteJob->setLimitRowCount((int) $tokens->getCurrentTokenString());
}
}
return $deleteJob;
}
