return "DATE"
class OracleText(sqltypes.TEXT):
def get_col_spec(self):
- return "TEXT"
+ return "CLOB"
class OracleString(sqltypes.String):
def get_col_spec(self):
return "VARCHAR(%(length)s)" % {'length' : self.length}
return None
def pre_exec(self, connection, cursor, statement, parameters, echo = None, compiled = None, **kwargs):
- # if a sequence was explicitly defined we do it here
if compiled is None: return
if getattr(compiled, "isinsert", False):
if isinstance(parameters, list):
connection.commit()
def proxy(self):
- return lambda s, p = None: self.execute(s, p, commit=True)
+ return lambda s, p = None: self.execute(s, p)
def connection(self):
return self._pool.connect()
self.do_rollback(self.context.transaction)
self.context.transaction = None
self.context.tcount = None
- else:
- self.do_rollback(self.connection())
def commit(self):
if self.context.transaction is not None:
self.do_commit(self.context.transaction)
self.context.transaction = None
self.context.tcount = None
- else:
- self.do_commit(self.connection())
def pre_exec(self, connection, cursor, statement, parameters, many = False, echo = None, **kwargs):
pass
else:
c = connection.cursor()
- self.pre_exec(connection, c, statement, parameters, echo = echo, **kwargs)
-
- if echo is True or self.echo:
- self.log(statement)
- self.log(repr(parameters))
-
- if isinstance(parameters, list):
- self._executemany(c, statement, parameters)
- else:
- self._execute(c, statement, parameters)
- self.post_exec(connection, c, statement, parameters, echo = echo, **kwargs)
- if commit:
- connection.commit()
+ try:
+ self.pre_exec(connection, c, statement, parameters, echo = echo, **kwargs)
+
+ if echo is True or self.echo:
+ self.log(statement)
+ self.log(repr(parameters))
+ if isinstance(parameters, list):
+ self._executemany(c, statement, parameters)
+ else:
+ self._execute(c, statement, parameters)
+ self.post_exec(connection, c, statement, parameters, echo = echo, **kwargs)
+ if commit or self.context.transaction is None:
+ self.do_commit(connection)
+ except:
+ self.do_rollback(connection)
+ # TODO: wrap DB exceptions ?
+ raise
return ResultProxy(c, self, typemap = typemap)
def _execute(self, c, statement, parameters):
i+=1
def _get_col(self, row, key):
- rec = self.props[key.lower()]
+ if isinstance(key, schema.Column):
+ try:
+ rec = self.props[key.label.lower()]
+ except KeyError:
+ try:
+ rec = self.props[key.key.lower()]
+ except KeyError:
+ rec = self.props[key.name.lower()]
+ elif isinstance(key, str):
+ rec = self.props[key.lower()]
+ else:
+ rec = self.props[key]
return rec[0].convert_result_value(row[rec[1]])
def fetchall(self):
objectstore.uow().register_clean(value)
if len(mappers):
- return result + otherresults
+ return [result] + otherresults
else:
return result
in this case, the developer must insure that an adequate set of columns exists in the
rowset with which to build new object instances."""
if arg is not None and isinstance(arg, sql.Select):
- return self._select_statement(arg, **params)
+ return self.select_statement(arg, **params)
else:
- return self._select_whereclause(arg, **params)
+ return self.select_whereclause(arg, **params)
+
+ def select_whereclause(self, whereclause = None, order_by = None, **params):
+ statement = self._compile(whereclause, order_by = order_by)
+ return self.select_statement(statement, **params)
+
+ def select_statement(self, statement, **params):
+ statement.use_labels = True
+ return self.instances(statement.execute(**params))
+
+ def select_text(self, text, **params):
+ t = sql.text(text, engine=self.primarytable.engine)
+ return self.instances(t.execute(**params))
def _getattrbycolumn(self, obj, column):
try:
statement.use_labels = True
return statement
- def _select_whereclause(self, whereclause = None, order_by = None, **params):
- statement = self._compile(whereclause, order_by = order_by)
- return self._select_statement(statement, **params)
-
- def _select_statement(self, statement, **params):
- statement.use_labels = True
- return self.instances(statement.execute(**params))
def _identity_key(self, row):
return objectstore.get_row_key(row, self.class_, self.primarytable, self.primary_keys[self.table])
# check if primary keys in the result are None - this indicates
# an instance of the object is not present in the row
for col in self.primary_keys[self.table]:
- if row[col.label] is None:
+ if row[col] is None:
return None
# plugin point
instance = self.extension.create_instance(self, row, imap, self.class_)
def execute(self, instance, row, identitykey, imap, isnew):
if isnew:
- instance.__dict__[self.key] = row[self.columns[0].label]
- #setattr(instance, self.key, row[self.columns[0].label])
+ instance.__dict__[self.key] = row[self.columns[0]]
class PropertyLoader(MapperProperty):
may be synonymous with the table argument or can be a larger construct containing that table.
return value: a tuple object which is used as an identity key.
"""
- return (class_, table, tuple([row[column.label] for column in primary_keys]))
+ return (class_, table, tuple([row[column] for column in primary_keys]))
def begin():
"""begins a new UnitOfWork transaction. the next commit will affect only
else:
return BindParamClause(key, value, type=type)
-def text(text):
- return TextClause(text)
+def text(text, engine=None):
+ return TextClause(text, engine=engine)
def null():
return Null()
class TextClause(ClauseElement):
"""represents any plain text WHERE clause or full SQL statement"""
- def __init__(self, text = ""):
+ def __init__(self, text = "", engine=None):
self.text = text
self.parens = False
+ self.engine = engine
def accept_visitor(self, visitor):
visitor.visit_textclause(self)
def hash_key(self):
return "Address: " + repr(getattr(self, 'address_id', None)) + " " + repr(getattr(self, 'user_id', None)) + " " + repr(self.email_address)
class Order(object):
+ def __init__(self):
+ self.isopen=0
def __repr__(self):
return "Order: " + repr(self.description) + " " + repr(self.isopen) + " " + repr(getattr(self, 'items', None))
projects / thirdparty / sqlalchemy / sqlalchemy.git / commitdiff
