def test_alias(self):
t = table("sometable", column("col1"), column("col2"))
s = select([t.alias()])
self.assert_compile(
s,
"SELECT sometable_1.col1, sometable_1.col2 "
"FROM sometable AS sometable_1",
)
dialect = firebird.FBDialect()
dialect._version_two = False
self.assert_compile(
s,
"SELECT sometable_1.col1, sometable_1.col2 "
"FROM sometable sometable_1",
dialect=dialect,
)
def teststringadapt(self):
"""test that String with no size becomes TEXT, *all* others stay as varchar/String"""
oracle_dialect = oracle.OracleDialect()
mysql_dialect = mysql.MySQLDialect()
postgres_dialect = postgres.PGDialect()
firebird_dialect = firebird.FBDialect()
for dialect, start, test in [
(oracle_dialect, String(), oracle.OracleString),
(oracle_dialect, VARCHAR(), oracle.OracleString),
(oracle_dialect, String(50), oracle.OracleString),
(oracle_dialect, Unicode(), oracle.OracleString),
(oracle_dialect, UnicodeText(), oracle.OracleText),
(oracle_dialect, NCHAR(), oracle.OracleString),
(oracle_dialect, oracle.OracleRaw(50), oracle.OracleRaw),
(mysql_dialect, String(), mysql.MSString),
(mysql_dialect, VARCHAR(), mysql.MSString),
(mysql_dialect, String(50), mysql.MSString),
(mysql_dialect, Unicode(), mysql.MSString),
(mysql_dialect, UnicodeText(), mysql.MSText),
(mysql_dialect, NCHAR(), mysql.MSNChar),
(postgres_dialect, String(), postgres.PGString),
(postgres_dialect, VARCHAR(), postgres.PGString),
(postgres_dialect, String(50), postgres.PGString),
(postgres_dialect, Unicode(), postgres.PGString),
(postgres_dialect, UnicodeText(), postgres.PGText),
(postgres_dialect, NCHAR(), postgres.PGString),
(firebird_dialect, String(), firebird.FBString),
(firebird_dialect, VARCHAR(), firebird.FBString),
(firebird_dialect, String(50), firebird.FBString),
(firebird_dialect, Unicode(), firebird.FBString),
(firebird_dialect, UnicodeText(), firebird.FBText),
(firebird_dialect, NCHAR(), firebird.FBString),
]:
assert isinstance(
start.dialect_impl(dialect),
test), "wanted %r got %r" % (test, start.dialect_impl(dialect))
class CompileTest(fixtures.TestBase, AssertsCompiledSQL):
__dialect__ = firebird.FBDialect()
def test_alias(self):
t = table("sometable", column("col1"), column("col2"))
s = select([t.alias()])
self.assert_compile(
s,
"SELECT sometable_1.col1, sometable_1.col2 "
"FROM sometable AS sometable_1",
)
dialect = firebird.FBDialect()
dialect._version_two = False
self.assert_compile(
s,
"SELECT sometable_1.col1, sometable_1.col2 "
"FROM sometable sometable_1",
dialect=dialect,
)
def test_varchar_raise(self):
for type_ in (
String,
VARCHAR,
String(),
VARCHAR(),
Unicode,
Unicode(),
):
type_ = sqltypes.to_instance(type_)
assert_raises_message(
exc.CompileError,
"VARCHAR requires a length on dialect firebird",
type_.compile,
dialect=firebird.dialect(),
)
t1 = Table("sometable", MetaData(), Column("somecolumn", type_))
assert_raises_message(
exc.CompileError,
r"\(in table 'sometable', column 'somecolumn'\)\: "
r"(?:N)?VARCHAR requires a length on dialect firebird",
schema.CreateTable(t1).compile,
dialect=firebird.dialect(),
)
def test_function(self):
self.assert_compile(func.foo(1, 2), "foo(:foo_1, :foo_2)")
self.assert_compile(func.current_time(), "CURRENT_TIME")
self.assert_compile(func.foo(), "foo")
m = MetaData()
t = Table("sometable", m, Column("col1", Integer),
Column("col2", Integer))
self.assert_compile(
select([func.max(t.c.col1)]),
"SELECT max(sometable.col1) AS max_1 FROM "
"sometable",
)
def test_substring(self):
self.assert_compile(
func.substring("abc", 1, 2),
"SUBSTRING(:substring_1 FROM :substring_2 "
"FOR :substring_3)",
)
self.assert_compile(
func.substring("abc", 1),
"SUBSTRING(:substring_1 FROM :substring_2)",
)
def test_update_returning(self):
table1 = table(
"mytable",
column("myid", Integer),
column("name", String(128)),
column("description", String(128)),
)
u = update(table1,
values=dict(name="foo")).returning(table1.c.myid,
table1.c.name)
self.assert_compile(
u,
"UPDATE mytable SET name=:name RETURNING "
"mytable.myid, mytable.name",
)
u = update(table1, values=dict(name="foo")).returning(table1)
self.assert_compile(
u,
"UPDATE mytable SET name=:name RETURNING "
"mytable.myid, mytable.name, "
"mytable.description",
)
u = update(table1, values=dict(name="foo")).returning(
func.length(table1.c.name))
self.assert_compile(
u,
"UPDATE mytable SET name=:name RETURNING "
"char_length(mytable.name) AS length_1",
)
def test_insert_returning(self):
table1 = table(
"mytable",
column("myid", Integer),
column("name", String(128)),
column("description", String(128)),
)
i = insert(table1,
values=dict(name="foo")).returning(table1.c.myid,
table1.c.name)
self.assert_compile(
i,
"INSERT INTO mytable (name) VALUES (:name) "
"RETURNING mytable.myid, mytable.name",
)
i = insert(table1, values=dict(name="foo")).returning(table1)
self.assert_compile(
i,
"INSERT INTO mytable (name) VALUES (:name) "
"RETURNING mytable.myid, mytable.name, "
"mytable.description",
)
i = insert(table1, values=dict(name="foo")).returning(
func.length(table1.c.name))
self.assert_compile(
i,
"INSERT INTO mytable (name) VALUES (:name) "
"RETURNING char_length(mytable.name) AS "
"length_1",
)
def test_charset(self):
"""Exercise CHARACTER SET options on string types."""
columns = [
(firebird.CHAR, [1], {}, "CHAR(1)"),
(
firebird.CHAR,
[1],
{
"charset": "OCTETS"
},
"CHAR(1) CHARACTER SET OCTETS",
),
(firebird.VARCHAR, [1], {}, "VARCHAR(1)"),
(
firebird.VARCHAR,
[1],
{
"charset": "OCTETS"
},
"VARCHAR(1) CHARACTER SET OCTETS",
),
]
for type_, args, kw, res in columns:
self.assert_compile(type_(*args, **kw), res)
def test_quoting_initial_chars(self):
self.assert_compile(column("_somecol"), '"_somecol"')
self.assert_compile(column("$somecol"), '"$somecol"')
@testing.combinations(("no_persisted", "ignore"), ("persisted_none", None),
id_="ia")
def test_column_computed(self, persisted):
m = MetaData()
kwargs = {"persisted": persisted} if persisted != "ignore" else {}
t = Table(
"t",
m,
Column("x", Integer),
Column("y", Integer, Computed("x + 2", **kwargs)),
)
self.assert_compile(
schema.CreateTable(t),
"CREATE TABLE t (x INTEGER, y INTEGER GENERATED "
"ALWAYS AS (x + 2))",
)
@testing.combinations(("persisted_true", True), ("persisted_false", False),
id_="ia")
def test_column_computed_raises(self, persisted):
m = MetaData()
t = Table(
"t",
m,
Column("x", Integer),
Column("y", Integer, Computed("x + 2", persisted=persisted)),
)
assert_raises_message(
exc.CompileError,
"Firebird computed columns do not support a persistence method",
schema.CreateTable(t).compile,
dialect=firebird.dialect(),
)
class CompileTest(TestBase, AssertsCompiledSQL):
__dialect__ = firebird.FBDialect()
def test_alias(self):
t = table('sometable', column('col1'), column('col2'))
s = select([t.alias()])
self.assert_compile(
s,
"SELECT sometable_1.col1, sometable_1.col2 FROM sometable sometable_1"
)
def test_function(self):
self.assert_compile(func.foo(1, 2), "foo(:foo_1, :foo_2)")
self.assert_compile(func.current_time(), "CURRENT_TIME")
self.assert_compile(func.foo(), "foo")
m = MetaData()
t = Table('sometable', m, Column('col1', Integer),
Column('col2', Integer))
self.assert_compile(
select([func.max(t.c.col1)]),
"SELECT max(sometable.col1) AS max_1 FROM sometable")
def test_substring(self):
self.assert_compile(
func.substring('abc', 1, 2),
"SUBSTRING(:substring_1 FROM :substring_2 FOR :substring_3)")
self.assert_compile(func.substring('abc', 1),
"SUBSTRING(:substring_1 FROM :substring_2)")
def test_update_returning(self):
table1 = table(
'mytable',
column('myid', Integer),
column('name', String(128)),
column('description', String(128)),
)
u = update(table1,
values=dict(name='foo'),
firebird_returning=[table1.c.myid, table1.c.name])
self.assert_compile(
u,
"UPDATE mytable SET name=:name RETURNING mytable.myid, mytable.name"
)
u = update(table1,
values=dict(name='foo'),
firebird_returning=[table1])
self.assert_compile(u, "UPDATE mytable SET name=:name "\
"RETURNING mytable.myid, mytable.name, mytable.description")
u = update(table1,
values=dict(name='foo'),
firebird_returning=[func.length(table1.c.name)])
self.assert_compile(
u,
"UPDATE mytable SET name=:name RETURNING char_length(mytable.name)"
)
def test_insert_returning(self):
table1 = table(
'mytable',
column('myid', Integer),
column('name', String(128)),
column('description', String(128)),
)
i = insert(table1,
values=dict(name='foo'),
firebird_returning=[table1.c.myid, table1.c.name])
self.assert_compile(
i,
"INSERT INTO mytable (name) VALUES (:name) RETURNING mytable.myid, mytable.name"
)
i = insert(table1,
values=dict(name='foo'),
firebird_returning=[table1])
self.assert_compile(i, "INSERT INTO mytable (name) VALUES (:name) "\
"RETURNING mytable.myid, mytable.name, mytable.description")
i = insert(table1,
values=dict(name='foo'),
firebird_returning=[func.length(table1.c.name)])
self.assert_compile(
i,
"INSERT INTO mytable (name) VALUES (:name) RETURNING char_length(mytable.name)"
)
