Hi,
I've written a small Pylons application to manage some data for a
client. It's real basic CRUD stuff here, nothing fancy. I notice
though that from time to time the client will try to add new data and
she gets this error message:
DBAPIError: (TypeError) expecting None or a string u'SELECT
roleseq.nextval FROM DUAL' {}
I go over the data and there are no issues...in fact I can input the
same data and it saves just fine. Sometimes I do get the error though.
The rest of the error message is below for reference. Any ideas/
pointers/hints as to what's going on here would be great. Hazings
welcome too.
Thanks!
Jon
Module ilmcredits.controllers.role:23 in save
<< role.text = role_name
Session.save(role)
Session.commit()
redirect_to('/role')>> Session.commit()
Module sqlalchemy.orm.scoping:74 in do
<< def instrument(name):
def do(self, *args, **kwargs):
return getattr(self.registry(), name)(*args, **kwargs)
return do
for meth in ('get', 'load', 'close', 'save', 'commit', 'update',
'save_or_update', 'flush', 'query', 'delete', 'merge', 'clear',
'refresh', 'expire', 'expunge', 'rollback', 'begin', 'begin_nested',
'connection', 'execute', 'scalar', 'get_bind', 'is_modified',
'__contains__', '__iter__'):>> return getattr(self.registry(), name)
(*args, **kwargs)
Module sqlalchemy.orm.session:483 in commit
<< raise exceptions.InvalidRequestError("No
transaction is begun.")
else:
self.transaction = self.transaction.commit()
if self.transaction is None and self.transactional:
self.begin()>> self.transaction =
self.transaction.commit()
Module sqlalchemy.orm.session:210 in commit
<<
if self.autoflush:
self.session.flush()
if self.session.twophase:>> self.session.flush()
Module sqlalchemy.orm.session:683 in flush
<< """
self.uow.flush(self, objects)
def get(self, class_, ident, **kwargs):>>
self.uow.flush(self, objects)
Module sqlalchemy.orm.unitofwork:209 in flush
<< flush_context.transaction = session.transaction
try:
flush_context.execute()
if session.extension is not None:>>
flush_context.execute()
Module sqlalchemy.orm.unitofwork:436 in execute
<< self.logger.info("Task dump:\n" + head.dump())
if head is not None:
UOWExecutor().execute(self, head)
if self._should_log_info:
self.logger.info("Execute Complete")>>
UOWExecutor().execute(self, head)
Module sqlalchemy.orm.unitofwork:1055 in execute
<< def execute(self, trans, task, isdelete=None):
if isdelete is not True:
self.execute_save_steps(trans, task)
if isdelete is not False:
self.execute_delete_steps(trans, task)>>
self.execute_save_steps(trans, task)
Module sqlalchemy.orm.unitofwork:1069 in execute_save_steps
<<
def execute_save_steps(self, trans, task):
self.save_objects(trans, task)
self.execute_cyclical_dependencies(trans, task, False)
self.execute_per_element_childtasks(trans, task, False)>>
self.save_objects(trans, task)
Module sqlalchemy.orm.unitofwork:1060 in save_objects
<<
def save_objects(self, trans, task):
task.mapper.save_obj(task.polymorphic_tosave_objects,
trans)
def delete_objects(self, trans, task):>>
task.mapper.save_obj(task.polymorphic_tosave_objects, trans)
Module sqlalchemy.orm.mapper:1132 in save_obj
<< for rec in insert:
(obj, params, mapper, connection,
value_params) = rec
c =
connection.execute(statement.values(value_params), params)
primary_key = c.last_inserted_ids()>> c =
connection.execute(statement.values(value_params), params)
Module sqlalchemy.engine.base:789 in execute
<< for c in type(object).__mro__:
if c in Connection.executors:
return Connection.executors[c](self, object,
multiparams, params)
else:
raise exceptions.InvalidRequestError("Unexecutable
object type: " + str(type(object)))>> return Connection.executors[c]
(self, object, multiparams, params)
Module sqlalchemy.engine.base:840 in execute_clauseelement
<< else:
keys = None
return
self._execute_compiled(elem.compile(dialect=self.dialect,
column_keys=keys, inline=len(params) > 1), distilled_params=params)
def _execute_compiled(self, compiled, multiparams=None,
params=None, distilled_params=None):>> return
self._execute_compiled(elem.compile(dialect=self.dialect,
column_keys=keys, inline=len(params) > 1), distilled_params=params)
Module sqlalchemy.engine.base:849 in _execute_compiled
<< if distilled_params is None:
distilled_params = self.__distill_params(multiparams,
params)
context =
self.__create_execution_context(compiled=compiled,
parameters=distilled_params)
context.pre_execution()>> context =
self.__create_execution_context(compiled=compiled,
parameters=distilled_params)
Module sqlalchemy.engine.base:858 in __create_execution_context
<<
def __create_execution_context(self, **kwargs):
return
self.engine.dialect.create_execution_context(connection=self,
**kwargs)
def __execute_raw(self, context):>> return
self.engine.dialect.create_execution_context(connection=self,
**kwargs)
Module sqlalchemy.databases.oracle:357 in create_execution_context
<<
def create_execution_context(self, *args, **kwargs):
return OracleExecutionContext(self, *args, **kwargs)
def has_table(self, connection, table_name, schema=None):>>
return OracleExecutionContext(self, *args, **kwargs)
Module sqlalchemy.engine.default:173 in __init__
<<
self.cursor = self.create_cursor()
self.__process_defaults()
self.parameters =
self.__convert_compiled_params(self.compiled_parameters)>>
self.__process_defaults()
Module sqlalchemy.engine.default:365 in __process_defaults
<< for c in self.compiled.prefetch:
if self.isinsert:
val = drunner.get_column_default(c)
else:
val = drunner.get_column_onupdate(c)>>
val = drunner.get_column_default(c)
Module sqlalchemy.engine.base:1662 in get_column_default
<< def get_column_default(self, column):
if column.default is not None:
return self.traverse_single(column.default)
else:
return None>> return
self.traverse_single(column.default)
Module sqlalchemy.sql.visitors:30 in traverse_single
<< meth = getattr(self, "visit_%s" % obj.__visit_name__,
None)
if meth:
return meth(obj, **kwargs)
def traverse_chained(self, obj, **kwargs):>> return meth(obj,
**kwargs)
Module sqlalchemy.databases.oracle:715 in visit_sequence
<< class OracleDefaultRunner(base.DefaultRunner):
def visit_sequence(self, seq):
return self.execute_string("SELECT " +
self.dialect.identifier_preparer.format_sequence(seq) + ".nextval FROM
DUAL", {})
class OracleIdentifierPreparer(compiler.IdentifierPreparer):>>
return self.execute_string("SELECT " +
self.dialect.identifier_preparer.format_sequence(seq) + ".nextval FROM
DUAL", {})
Module sqlalchemy.engine.base:1697 in execute_string
<< and return a scalar result. and return a scalar
result."""
conn = self.context._connection
conn._cursor_execute(self.context.cursor, stmt, params)
return self.context.cursor.fetchone()[0]>>
conn._cursor_execute(self.context.cursor, stmt, params)
Module sqlalchemy.engine.base:880 in _cursor_execute
<< if self.__close_with_result:
self.close()
raise exceptions.DBAPIError.instance(statement,
parameters, e)
def _cursor_executemany(self, cursor, statement, parameters,
context=None):>> raise exceptions.DBAPIError.instance(statement,
parameters, e)
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"sqlalchemy" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at
http://groups.google.com/group/sqlalchemy?hl=en
-~----------~----~----~----~------~----~------~--~---
