def test_keyless_schema(self):
schema = records.RecordsSchema('test')
self.assertEqual(schema.key_column_names, ())
self.assertEqual(schema.value_column_names, ('data', ))
engine = sqlite.create_engine('sqlite://', trace=True)
conn = engine.connect()
with self.assertLogs(sqlite.__name__, level='DEBUG') as cm:
rs = records.Records(conn, schema)
# Repeated creations are okay.
for _ in range(3):
rs.create_all()
for _ in range(3):
rs.create_indices()
self.assertRegex(
'\n'.join(cm.output),
r'(?m:'
r'^CREATE TABLE test \($\n'
r'^\s*data BLOB NOT NULL$\n'
r'^\s*\)$\n'
r')',
)
self.assertFalse(schema.is_keyed())
with self.assertRaisesRegex(AssertionError, r'expect keyed schema'):
schema.assert_keyed()
schema.assert_keyless()
conn.close()
def test_create_engine(self):
with contextlib.ExitStack() as stack:
cm = stack.enter_context(
self.assertLogs(sqlite.__name__, level='DEBUG'))
# Use real file to force opening multiple connections.
f = stack.enter_context(tempfile.NamedTemporaryFile())
engine = sqlite.create_engine(
# pylint: disable=no-member
'sqlite:///%s' % f.name,
trace=True,
pragmas=(('auto_vacuum', 0), ),
)
metadata, table = self.make_metadata()
conns = [stack.enter_context(engine.connect()) for _ in range(2)]
for conn in conns:
metadata.create_all(conn)
# pylint: disable=no-value-for-parameter
for i, conn in enumerate(conns):
with conn.begin():
conn.execute(table.insert(), [{'test_data': 10 + i}])
for i, conn in enumerate(conns):
conn.execute(table.insert(), [{'test_data': i}])
self.assertRegex(
'\n'.join(cm.output),
r'(?m:'
r'^.* PRAGMA foreign_keys = ON$'
r'\n^.* PRAGMA auto_vacuum = 0$'
r'\n^.* PRAGMA main\.table_info\("test_table"\)$'
r'\n^.* PRAGMA temp\.table_info\("test_table"\)$'
r'(?s:.*CREATE TABLE.*)'
r'\n^.* PRAGMA main\.table_info\("test_table"\)$'
r'\n^.* BEGIN$'
r'\n^.* INSERT INTO test_table \(test_data\) VALUES \(10\)$'
r'\n^.* COMMIT$'
r'\n^.* BEGIN$'
r'\n^.* INSERT INTO test_table \(test_data\) VALUES \(11\)$'
r'\n^.* COMMIT$'
r'\n^.* INSERT INTO test_table \(test_data\) VALUES \(0\)$'
r'\n^.* INSERT INTO test_table \(test_data\) VALUES \(1\)$'
r')',
)
def test_keyed_schema(self):
schema = records.RecordsSchema(
'test',
[('key1', Integer), ('key2', String)],
index_column_names=[
('key1', 'data'),
('key2', 'data'),
],
)
self.assertEqual(schema.key_column_names, ('key1', 'key2'))
self.assertEqual(schema.value_column_names, ('data', ))
engine = sqlite.create_engine('sqlite://', trace=True)
conn = engine.connect()
with self.assertLogs(sqlite.__name__, level='DEBUG') as cm:
rs = records.Records(conn, schema)
# Repeated creations are okay.
for _ in range(3):
rs.create_all()
for _ in range(3):
rs.create_indices()
self.assertRegex(
'\n'.join(cm.output),
r'(?m:'
r'^CREATE TABLE test \($\n'
r'^.*key1 INTEGER NOT NULL,\s*$\n'
r'^.*key2 VARCHAR NOT NULL,\s*$\n'
r'^.*data BLOB NOT NULL,\s*$\n'
r'^.*PRIMARY KEY \(key1, key2\)$\n'
r'(?s:.*)' # 's' makes '.' match multiple lines.
r'^.*CREATE INDEX IF NOT EXISTS '
r'index_test__key1__data ON test \(key1, data\)$\n'
r'^.*CREATE INDEX IF NOT EXISTS '
r'index_test__key2__data ON test \(key2, data\)$\n'
r')',
)
self.assertTrue(schema.is_keyed())
schema.assert_keyed()
with self.assertRaisesRegex(AssertionError, r'expect keyless schema'):
schema.assert_keyless()
conn.close()
def setUp(self):
super().setUp()
self.engine = sqlite.create_engine('sqlite://')
metadata = sqlalchemy.MetaData()
self.tables = schemas.make_tables(metadata)
metadata.create_all(self.engine)
def setUp(self):
super().setUp()
self.engine = sqlite.create_engine('sqlite://')
self.conn = self.engine.connect()
def test_db_url(self):
with self.assertRaisesRegex(AssertionError, r'expect sqlite URL'):
sqlite.create_engine('postgresql+psycopg2://')