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 sqlalchemy@googlegroups.com 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 -~----------~----~----~----~------~----~------~--~---