def test_space(self) -> None:
self.mock_config['query'] = {
'base': {'required': {'space': 'h3'}, 'optional': ['col1']},
}
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.space('835525fffffffff')
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table "
"WHERE h3='835525fffffffff' ;",
table.statements[0]
)
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.space(['835525fffffffff'])
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table "
"WHERE h3 IN ('835525fffffffff') ;",
table.statements[0]
)
def test_insert(self) -> None:
table = CassandraTable(self.mock_config, self.keyspace)
table.insert({
'col1': 'mock_id',
'col2': 1546304400000,
'col3': 26.919388,
'col4': -8.932613
}, keyspace='mock_keyspace')
self.assertEqual(1, len(table.statements))
self.assertEqual(
"INSERT INTO mock_keyspace.mock_table "
"JSON '{\"col1\": \"mock_id\", \"col2\": 1546304400000, "
"\"col3\": 26.919388, \"col4\": -8.932613, \"day\": 1546300800000, "
"\"h3\": \"835525fffffffff\"}' ;",
table.statements[0]
)
for _ in range(4):
table = table.insert({
'col1': 'mock_id',
'col2': 1546304400000,
'col3': 26.919388,
'col4': -8.932613
}, keyspace='mock_keyspace')
self.assertEqual(5, len(table.statements))
for i in range(5):
self.assertEqual(
"INSERT INTO mock_keyspace.mock_table "
"JSON '{\"col1\": \"mock_id\", \"col2\": 1546304400000, "
"\"col3\": 26.919388, \"col4\": -8.932613, "
"\"day\": 1546300800000, \"h3\": \"835525fffffffff\"}' ;",
table.statements[i]
)
def test_is_query_valid_raises_date_not_defined_error(self) -> None:
self.mock_config['split'] = 'day'
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.id('mock_col1')
with self.assertRaises(DateNotDefinedError):
table._is_query_valid()
def test_get(self) -> None:
table = CassandraTable(self.mock_config, self.keyspace)
col = table.get('col4')
self.assertEqual('col4', col.name)
col = table.get('day')
self.assertEqual('day', col.name)
col = table.get('month')
self.assertIsNone(col)
def test_model(self) -> None:
class MockTable(BaseModel):
col1: str = None
col2: int = None
col3: float = None
col4: float = None
col5: int = None
day: int = None
h3: str = None
mock_keyspace = MagicMock(spec=CassandraKeyspace)
model = CassandraTable(self.mock_config, keyspace=mock_keyspace).model
self.assertEqual(MockTable.schema(), model.schema())
def test_create_with_split(self) -> None:
self.mock_config['split'] = 'year'
self.mock_config['generated_columns'] = {
'day': 'col2',
'year': 'col2',
'h3': 'col3,col4'
}
table = \
CassandraTable(self.mock_config, self.keyspace) \
.create(
keyspace='mock_keyspace',
gc_grace_seconds=1000,
if_not_exists=False,
create_materialized_views=False
) \
.time(datetime(2019, 1, 1), datetime(2020, 12, 31))
self.assertEqual(2, len(table.statements))
self.assertEqual(
"CREATE TABLE mock_keyspace.mock_table_2019 ( "
"col1 TEXT, col2 BIGINT, col3 FLOAT, col4 FLOAT, col5 SMALLINT, "
"day BIGINT, year BIGINT, h3 TEXT, "
"PRIMARY KEY ( (col1), col2 ) "
") WITH CLUSTERING ORDER BY ( id DESC ) AND gc_grace_seconds=1000;",
table.statements[0]
)
self.assertEqual(
"CREATE TABLE mock_keyspace.mock_table_2020 ( "
"col1 TEXT, col2 BIGINT, col3 FLOAT, col4 FLOAT, col5 SMALLINT, "
"day BIGINT, year BIGINT, h3 TEXT, "
"PRIMARY KEY ( (col1), col2 ) "
") WITH CLUSTERING ORDER BY ( id DESC ) AND gc_grace_seconds=1000;",
table.statements[1]
)
def test_missing_column(self):
mock_keyspace = CassandraKeyspace(self.mock_config)
table = CassandraTable(self.mock_config, mock_keyspace)
with self.assertRaises(MissingColumnError):
table \
.query('base', keyspace='mock_keyspace') \
.select('missing_column')
def test_insert_with_split(self) -> None:
self.mock_config['split'] = 'day'
table = CassandraTable(self.mock_config, self.keyspace)
table.insert({
'col1': 'mock_id',
'col2': 1546304400000,
'col3': 26.919388,
'col4': -8.932613
}, keyspace='mock_keyspace')
self.assertEqual(1, len(table.statements))
self.assertEqual(
"INSERT INTO mock_keyspace.mock_table_01_01_2019 "
"JSON '{\"col1\": \"mock_id\", \"col2\": 1546304400000, "
"\"col3\": 26.919388, \"col4\": -8.932613, "
"\"day\": 1546300800000, \"h3\": \"835525fffffffff\"}' ;",
table.statements[0]
)
def test_query(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace')
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table ;",
table.statements[0]
)
def test_between_including_prepare(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.between_including('col2')
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table "
"WHERE col2 >= ? AND col2 <= ? ;",
table.statements[0]
)
def test_select(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.select(['col1', 'col2', 'col3'])
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT col1, col2, col3 "
"FROM mock_keyspace.mock_table ;",
table.statements[0]
)
def test_query_with_split(self) -> None:
self.mock_config['split'] = 'day'
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace')
self.assertEqual(1, len(table.statements))
self.assertIn('_{date}', table.statements[0])
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table_{date} ;",
table.statements[0]
)
def test_equals(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.equals('col1', 'mock_id')
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table "
"WHERE col1='mock_id' ;",
table.statements[0]
)
def test_higher_or_equal_than_prepare(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.higher_or_equal_than('col2')
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table "
"WHERE col2 >= ? ;",
table.statements[0]
)
def test_lower_or_equal_than(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.lower_or_equal_than('col2', 1546304400000)
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table "
"WHERE col2 <= 1546304400000 ;",
table.statements[0]
)
def test_among_prepare(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.among('col1')
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table "
"WHERE col1 IN (?) ;",
table.statements[0]
)
def test_has_split(self) -> None:
table = CassandraTable(self.mock_config, self.keyspace)
self.assertFalse(table.has_split())
self.mock_config['split'] = 'day'
table = CassandraTable(self.mock_config, self.keyspace)
self.assertTrue(table.has_split())
def test_between(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.between('col2', 1546304400000, 1546304400010)
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table "
"WHERE col2 > 1546304400000 "
"AND col2 < 1546304400010 ;",
table.statements[0]
)
def test_not_a_required_column(self):
mock_keyspace = CassandraKeyspace(self.mock_config)
table = CassandraTable(self.mock_config, mock_keyspace)
mock_date = datetime.now()
with self.assertRaises(NotARequiredColumnError):
table \
.query('base', keyspace='mock_keyspace') \
.time(mock_date, mock_date)
with self.assertRaises(NotARequiredColumnError):
table \
.query('base', keyspace='mock_keyspace') \
.space('mock_hex')
self.mock_config['query'] = {'base': {'required': {'time': 'col2'}}}
mock_keyspace = CassandraKeyspace(self.mock_config)
table = CassandraTable(self.mock_config, mock_keyspace)
with self.assertRaises(NotARequiredColumnError):
table \
.query('base', keyspace='mock_keyspace') \
.id('mock_id')
def test_drop_if_exists(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.drop(
keyspace='mock_keyspace',
if_exists=True,
drop_materialized_views=False
)
self.assertEqual(1, len(table.statements))
self.assertEqual(
"DROP TABLE IF EXISTS mock_keyspace.mock_table;",
table.statements[0]
)
def test_query_materialized_view(self) -> None:
self.mock_config['query'] = {
'base': {'required': {'id': 'col1'}, 'optional': ['day']},
'second': {'required': {'time': 'day'}, 'optional': ['col1']}
}
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('second', keyspace='mock_keyspace')
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table_second ;",
table.statements[0]
)
def test_replace(self) -> None:
statement = "SELECT * FROM {keyspace_name}.{table_name} {where};"
keyspace_statement = \
CassandraTable._replace(statement, 'keyspace_name', 'mock_keyspace')
self.assertEqual(
keyspace_statement,
"SELECT * FROM mock_keyspace.{table_name} {where};"
)
table_statement = CassandraTable \
._replace(keyspace_statement, 'table_name', 'mock_table')
self.assertEqual(
table_statement,
"SELECT * FROM mock_keyspace.mock_table {where};"
)
final_statement = \
CassandraTable._replace(table_statement, 'where', '')
self.assertEqual(
final_statement,
"SELECT * FROM mock_keyspace.mock_table ;"
)
def test_time_prepare(self) -> None:
self.mock_config['query'] = {
'base': {'required': {'time': 'day'}, 'optional': ['col1']},
}
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.time(datetime(2019, 1, 1), datetime(2019, 1, 1), prepare=True)
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table "
"WHERE day=? ;",
table.statements[0]
)
def test_time_with_split(self) -> None:
self.mock_config['split'] = 'day'
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.time(datetime(2019, 1, 1), datetime(2019, 1, 2))
self.assertEqual(2, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table_01_01_2019 ;",
table.statements[0]
)
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table_02_01_2019 ;",
table.statements[1]
)
def test_time_with_required_and_split(self) -> None:
self.mock_config['query'] = {
'base': {'required': {'time': 'day'}, 'optional': ['col1']},
}
self.mock_config['split'] = 'year'
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.time(datetime(2019, 1, 1), datetime(2019, 1, 1))
self.assertEqual(1, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table_2019 "
"WHERE day=1546300800000 ;",
table.statements[0]
)
def test_create_if_not_exists(self) -> None:
table = \
CassandraTable(self.mock_config, self.keyspace) \
.create(
keyspace='mock_keyspace',
gc_grace_seconds=1000,
if_not_exists=True,
create_materialized_views=False
)
self.assertEqual(1, len(table.statements))
self.assertEqual(
"CREATE TABLE IF NOT EXISTS mock_keyspace.mock_table ( "
"col1 TEXT, col2 BIGINT, col3 FLOAT, col4 FLOAT, col5 SMALLINT, "
"day BIGINT, h3 TEXT, "
"PRIMARY KEY ( (col1), col2 ) "
") WITH CLUSTERING ORDER BY ( id DESC ) AND gc_grace_seconds=1000;",
table.statements[0]
)
def test_time_with_required_and_split_same(self) -> None:
self.mock_config['query'] = {
'base': {'required': {'time': 'day'}, 'optional': ['col1']},
}
self.mock_config['split'] = 'day'
table = \
CassandraTable(self.mock_config, self.keyspace) \
.query('base', keyspace='mock_keyspace') \
.time(datetime(2019, 1, 1), datetime(2019, 1, 2))
self.assertEqual(2, len(table.statements))
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table_01_01_2019 ;",
table.statements[0]
)
self.assertEqual(
"SELECT * FROM mock_keyspace.mock_table_02_01_2019 ;",
table.statements[1]
)
def test_get_columns(self) -> None:
table = CassandraTable(self.mock_config, self.keyspace)
cols = table.get_columns(names=['col1', 'col2', 'day'])
self.assertEqual(3, len(cols))
cols = table.get_columns(names=['col4'])
self.assertEqual('col4', cols[0].name)
cols = table.get_columns(alias=['ca', 'cb'])
self.assertEqual(2, len(cols))
cols = table.get_columns(alias=['ac'])
self.assertEqual('col4', cols[0].name)
def test_drop_with_materialized_views(self) -> None:
self.mock_config['query'] = {
'base': {'required': {'id': 'col1'}, 'optional': ['day']},
'second': {'required': {'time': 'day'}, 'optional': ['col1']}
}
table = \
CassandraTable(self.mock_config, self.keyspace) \
.drop(
keyspace='mock_keyspace',
if_exists=False,
drop_materialized_views=True
)
self.assertEqual(2, len(table.statements))
self.assertEqual(
"DROP MATERIALIZED VIEW mock_keyspace.mock_table_second;",
table.statements[0]
)
self.assertEqual(
"DROP TABLE mock_keyspace.mock_table;",
table.statements[1]
)
def test_create_with_materialized_views(self) -> None:
self.mock_config['query'] = {
'base': {
'required': {'id': 'col1'},
'optional': ['day'],
'order': {'id': 'desc'}
},
'second': {
'required': {'time': 'day'},
'optional': ['col1'],
'order': {'day': 'desc'}
}
}
table = \
CassandraTable(self.mock_config, self.keyspace) \
.create(
keyspace='mock_keyspace',
gc_grace_seconds=1000,
if_not_exists=False,
create_materialized_views=True
)
self.assertEqual(2, len(table.statements))
self.assertEqual(
"CREATE TABLE mock_keyspace.mock_table ( "
"col1 TEXT, col2 BIGINT, col3 FLOAT, col4 FLOAT, col5 SMALLINT, "
"day BIGINT, h3 TEXT, "
"PRIMARY KEY ( (col1), day ) "
") WITH CLUSTERING ORDER BY ( id DESC ) AND gc_grace_seconds=1000;",
table.statements[0]
)
self.assertEqual(
"CREATE MATERIALIZED VIEW mock_keyspace.mock_table_second "
"AS SELECT * FROM mock_keyspace.mock_table "
"WHERE day IS NOT NULL AND col1 IS NOT NULL "
"PRIMARY KEY ( (day), col1 ) "
"WITH CLUSTERING ORDER BY ( day DESC ) "
"AND gc_grace_seconds=1000;",
table.statements[1]
)
