FROM rdb$dependencies trigdep2
WHERE trigdep2.rdb$dependent_name = trigdep.rdb$dependent_name) = 2
"""
- genc = connection.execute(genqry, [tablename, colname])
- genr = genc.fetchone()
+ genr = connection.execute(genqry, [tablename, colname]).first()
if genr is not None:
return dict(name=self.normalize_name(genr['fgenerator']))
def has_table(self, connection, table_name, schema=None):
cursor = connection.execute("""select tabname from systables where tabname=?""", table_name.lower() )
- return bool( cursor.fetchone() is not None )
+ return cursor.first() is not None
def reflecttable(self, connection, table, include_columns):
c = connection.execute ("select distinct OWNER from systables where tabname=?", table.name.lower() )
bind.append(denormalize(schema))
rp = connection.execute(sql, bind)
- found = bool(rp.fetchone())
- rp.close()
- return found
+ return bool(rp.first())
def table_names(self, connection, schema):
if schema is None:
"WHERE SEQUENCE_NAME=? ")
rp = connection.execute(sql, denormalize(name))
- found = bool(rp.fetchone())
- rp.close()
- return found
-
+ return bool(rp.first())
def _autoserial_column(table):
)
c = connection.execute(s)
- row = c.fetchone()
- return row is not None
+ return c.first() is not None
@reflection.cache
def get_schema_names(self, connection, **kw):
sql.text("select ident_seed(:seed), ident_incr(:incr)"),
{'seed':table_fullname, 'incr':table_fullname}
)
- row = cursor.fetchone()
- cursor.close()
+ row = cursor.first()
if not row is None:
colmap[ic]['sequence'].update({
'start' : int(row[0]),
sql.text("SELECT table_name FROM all_tables "
"WHERE table_name = :name AND owner = :schema_name"),
name=self.denormalize_name(table_name), schema_name=self.denormalize_name(schema))
- return cursor.fetchone() is not None
+ return cursor.first() is not None
def has_sequence(self, connection, sequence_name, schema=None):
if not schema:
sql.text("SELECT sequence_name FROM all_sequences "
"WHERE sequence_name = :name AND sequence_owner = :schema_name"),
name=self.denormalize_name(sequence_name), schema_name=self.denormalize_name(schema))
- return cursor.fetchone() is not None
+ return cursor.first() is not None
def normalize_name(self, name):
if name is None:
result = connection.execute(sql.text(q), **params)
if desired_owner:
- row = result.fetchone()
+ row = result.first()
if row:
return row['table_name'], row['table_owner'], row['db_link'], row['synonym_name']
else:
sql.bindparam('schema', unicode(schema), type_=sqltypes.Unicode)]
)
)
- return bool(cursor.fetchone())
+ return bool(cursor.first())
def has_sequence(self, connection, sequence_name):
cursor = connection.execute(
"AND nspname != 'information_schema' AND relname = :seqname)",
bindparams=[sql.bindparam('seqname', unicode(sequence_name), type_=sqltypes.Unicode)]
))
- return bool(cursor.fetchone())
+ return bool(cursor.first())
def table_names(self, connection, schema):
result = connection.execute(
def has_table(self, connection, tablename, schema=None):
# FIXME: ignore schemas for sybase
s = sql.select([tables.c.table_name], tables.c.table_name == tablename)
-
- c = connection.execute(s)
- row = c.fetchone()
- return row is not None
+ return connection.execute(s).first() is not None
def reflecttable(self, connection, table, include_columns):
# Get base columns
listener.connect = listener
engine = create_engine(testing.db.url)
engine.pool.add_listener(listener)
- engine.execute(select([1]))
+ engine.execute(select([1])).close()
assert called, "Listener not called on connect"