def _sub(self, token):
for i, child_token in enumerate(token.tokens):
if isinstance(child_token, Parenthesis):
self._sub(child_token)
elif isinstance(child_token, Function):
for func in self.query.selected_columns.sql_tokens:
if (isinstance(func, SQLFunc)
and func._token[0].value == child_token.value
):
token.tokens[i] = sqlparse(
f'"{self.query.left_table}"."{func.alias}"'
)[0][0]
break
else:
raise SQLDecodeError
elif isinstance(child_token, Comparison):
if isinstance(child_token[0], Function):
for func in self.query.selected_columns.sql_tokens:
if (isinstance(func, SQLFunc)
and func._token[0].value == child_token[0].value
):
child_token.tokens[0] = sqlparse(
f'"{self.query.left_table}"."{func.alias}"'
)[0][0]
break
else:
raise SQLDecodeError
def _sub(self, token):
for i, child_token in enumerate(token.tokens):
if isinstance(child_token, Parenthesis):
self._sub(child_token)
elif isinstance(child_token, Function):
for func in self.query.selected_columns.sql_tokens:
if (isinstance(func, SQLFunc)
and func._token[0].value == child_token.value
):
token.tokens[i] = sqlparse(
f'"{self.query.left_table}"."{func.alias}"'
)[0][0]
break
else:
raise SQLDecodeError
elif isinstance(child_token, Comparison):
if isinstance(child_token[0], Function):
for func in self.query.selected_columns.sql_tokens:
if (isinstance(func, SQLFunc)
and func._token[0].value == child_token[0].value
):
child_token.tokens[0] = sqlparse(
f'"{self.query.left_table}"."{func.alias}"'
)[0][0]
break
else:
raise SQLDecodeError
def parse(self):
logger.debug(f'\n sql_command: {self._sql}')
statement = sqlparse(self._sql)
if len(statement) > 1:
raise SQLDecodeError(self._sql)
statement = statement[0]
sm_type = statement.get_type()
try:
handler = self.FUNC_MAP[sm_type]
except KeyError:
logger.debug('\n Not implemented {} {}'.format(sm_type, statement))
raise NotImplementedError(f'{sm_type} command not implemented for SQL {self._sql}')
else:
try:
return handler(self, statement)
except SQLDecodeError as e:
print(f'FAILED SQL: {self._sql}')
raise e
except OperationFailure as e:
print(f'FAILED SQL: {self._sql}')
print(e.details)
raise e
def parse(self):
logger.debug(f'\n sql_command: {self._sql}')
statement = sqlparse(self._sql)
if len(statement) > 1:
raise SQLDecodeError(self._sql)
statement = statement[0]
sm_type = statement.get_type()
try:
handler = self.FUNC_MAP[sm_type]
except KeyError:
logger.debug('\n Not implemented {} {}'.format(sm_type, statement))
raise NotImplementedError(
f'{sm_type} command not implemented for SQL {self._sql}')
else:
try:
return handler(self, statement)
except OperationFailure as e:
import djongo
exe = SQLDecodeError(f'FAILED SQL: {self._sql}\n'
f'Pymongo error: {e.details}\n'
f'Version: {djongo.__version__}')
raise exe from e
except Exception as e:
import djongo
exe = SQLDecodeError(f'FAILED SQL: {self._sql}\n'
f'Version: {djongo.__version__}')
raise exe from e
def parse(self):
from .query import SelectQuery
self._in_query = SelectQuery(self.query.db,
self.query.connection_properties,
sqlparse(self._token.value[1:-1])[0],
self.query.params)
def parse(self):
from sql2mongo.query import SelectQuery
self._in_query = SelectQuery(
self.query.db_ref,
sqlparse(self._token.value[1:-1])[0],
self.query.params
)
def parse(self):
from .query import SelectQuery
self._in_query = SelectQuery(
self.query.db_ref,
sqlparse(self._token.value[1:-1])[0],
self.query.params
)
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if not isinstance(self.token[2], Parenthesis):
op = ParenthesisOp(0, sqlparse('(' + self.token.value[6:] + ')')[0][0], self.query)
else:
op = ParenthesisOp(0, self.token[2], self.query)
op.evaluate()
self._op = op
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
if not isinstance(self.token[2], Parenthesis):
op = ParenthesisOp(0, sqlparse('(' + self.token.value[6:] + ')')[0][0], self.query)
else:
op = ParenthesisOp(0, self.token[2], self.query)
op.evaluate()
self._op = op
def parse(self):
from .query import SelectQuery
tok = self.statement.next()
self._from_query = SelectQuery(
self.query.db,
self.query.connection_properties,
sqlparse(tok[0].value[1:-1])[0],
self.query.params
)
self.query.left_table = self._from_query.left_table
def __call__(self, query):
"""Execute raw SQL"""
b = sqlparse(query)[0].tokens
if b[0].value == "select":
print("this was a select statement!")
try:
self.cursor.execute(query)
result = self.cursor.fetchall()
except ProgrammingError as e:
result = e
self.conn.commit()
return result
def parse(self):
logger.debug(
f'sql_command: {self._sql}\n'
f'params: {self._params}'
)
statement = sqlparse(self._sql)
if len(statement) > 1:
raise SQLDecodeError(self._sql)
statement = statement[0]
sm_type = statement.get_type()
try:
handler = self.FUNC_MAP[sm_type]
except KeyError:
logger.debug('\n Not implemented {} {}'.format(sm_type, statement))
raise SQLDecodeError(f'{sm_type} command not implemented for SQL {self._sql}')
else:
try:
return handler(self, statement)
except MigrationError:
raise
except OperationFailure as e:
import djongo
exe = SQLDecodeError(
err_sql=self._sql,
params=self._params,
version=djongo.__version__
)
raise exe from e
except SQLDecodeError as e:
import djongo
e.err_sql = self._sql,
e.params = self._params,
e.version = djongo.__version__
raise e
except Exception as e:
import djongo
exe = SQLDecodeError(
err_sql=self._sql,
params=self._params,
version=djongo.__version__
)
raise exe from e
def _fill_in(self, token):
self._in = []
# Check for nested
if token[1].ttype == tokens.DML:
self.query.nested_query = SelectQuery(
self.query._result_ref,
sqlparse(token.value[1:-1])[0], self.params)
return
for index in SQLToken(token, self.query.alias2op):
if index is not None:
self._in.append(self.params[index])
else:
self._in.append(None)
def parse(self):
i = self.query.statement.value.find('HAVING')
if i == -1:
raise SQLDecodeError
having = self.query.statement.value[i:]
having = having.replace('HAVING', 'WHERE')
having = sqlparse(having)[0][0]
if not isinstance(having, Where):
raise SQLDecodeError
self.statement.skip(len(having.tokens) - 1)
self._sub(having)
having.value = str(having)
self.op = WhereOp(token=having,
query=self.query,
params=self.query.params)
def _fill_in(self, token):
self._in = []
# Check for nested
if token[1].ttype == tokens.DML:
self.query.nested_query = SelectQuery(
self.query._result_ref,
sqlparse(token.value[1:-1])[0],
self.params
)
return
for index in SQLToken(token, self.query.alias2op):
if index is not None:
self._in.append(self.params[index])
else:
self._in.append(None)
def parse(self):
i = self.query.statement.value.find('HAVING')
if i == -1:
raise SQLDecodeError
having = self.query.statement.value[i:]
having = having.replace('HAVING', 'WHERE')
having = sqlparse(having)[0][0]
if not isinstance(having, Where):
raise SQLDecodeError
self.end_id = self.begin_id + len(having.tokens) - 1
self._sub(having)
having.value = str(having)
self.op = WhereOp(
token_id=0,
token=having,
query=self.query,
params=self.query.params
)
def sql2html(sqlstr):
p = sqlparse(sqlstr)
s = p[0]
par = s.token_next_by_instance(0, sql.Parenthesis)
il = par.token_next_by_instance(0, sql.IdentifierList)
htmls = []
for n, i in enumerate(il.get_identifiers()):
if n < 4:
continue
if n > 5:
break
if i.ttype == sqltokens.String.Single:
val = i.value.strip("'")
if val:
htmls.append(val)
html = ''.join(htmls).replace(r'\r\n', '\r\n')
soup = BeautifulSoup(html, 'html.parser')
return ''.join(['<html><body>', soup.prettify(), '</body></html>'])
def sql2html(sqlstr):
p = sqlparse(sqlstr)
s = p[0]
par = s.token_next_by_instance(0, sql.Parenthesis)
il = par.token_next_by_instance(0, sql.IdentifierList)
htmls = []
for n, i in enumerate(il.get_identifiers()):
if n < 4:
continue
if n > 5:
break
if i.ttype == sqltokens.String.Single:
val = i.value.strip("'")
if val:
htmls.append(val)
html = ''.join(htmls).replace(r'\r\n', '\r\n')
soup = BeautifulSoup(html, 'html.parser')
return ''.join(['<html><body>', soup.prettify(), '</body></html>'])
def parse(self):
logger.debug(f'\n sql_command: {self._sql}')
statement = sqlparse(self._sql)
if len(statement) > 1:
raise SQLDecodeError(self._sql)
statement = statement[0]
sm_type = statement.get_type()
try:
handler = self.FUNC_MAP[sm_type]
except KeyError:
logger.debug('\n Not implemented {} {}'.format(sm_type, statement))
raise NotImplementedError(f'{sm_type} command not implemented for SQL {self._sql}')
else:
try:
return handler(self, statement)
except MigrationError:
raise
except OperationFailure as e:
import djongo
exe = SQLDecodeError(
f'FAILED SQL: {self._sql}\n'
f'Pymongo error: {e.details}\n'
f'Version: {djongo.__version__}'
)
raise exe from e
except Exception as e:
import djongo
exe = SQLDecodeError(
f'FAILED SQL: {self._sql}\n'
f'Version: {djongo.__version__}'
)
raise exe from e
def parse(self):
logger.debug(f'\n sql_command: {self._sql}')
statement = sqlparse(self._sql)
if len(statement) > 1:
raise SQLDecodeError(self._sql)
statement = statement[0]
sm_type = statement.get_type()
try:
handler = self.FUNC_MAP[sm_type]
except KeyError:
logger.debug('\n Not implemented {} {}'.format(sm_type, statement))
raise NotImplementedError(f'{sm_type} command not implemented for SQL {self._sql}')
else:
try:
return handler(self, statement)
except SQLDecodeError as e:
e.err_sql = self._sql
raise e
def parse(self):
self._in_query = SelectQuery(
self.query.db_ref,
sqlparse(self._token.value[1:-1])[0],
self.query.params
)
def __getitem__(self, item: slice):
start = (item.start or 0) + self._tok_id
stop = item.stop and self._tok_id + item.stop
sql = ''.join(str(tok) for tok in self._statement[start:stop])
sql = sqlparse(sql)[0]
return SQLStatement(sql)
