def test_retrieve(self):
table_a = self.data.partition_a.table()
start = self.data.timestamp_1
end = self.data.timestamp_1
entity = self.data.entities[1]
entities = [entity.id]
column_names = [
"CellID",
"CCR",
"CCRatts",
"Drops"]
create_column = partial(Column, table_a)
columns = map(create_column, column_names)
with closing(self.conn.cursor()) as cursor:
r = retrieve(cursor, [table_a], columns, entities, start, end)
eq_(len(r), 1)
first_result = head(r)
entity_id, timestamp, c1, c2, c3, c4 = first_result
eq_(entity_id, entity.id)
eq_(c4, 18)
def store(cursor, table, source):
columns = map(Column, head(source))
insert = partial(Insert(table, columns).execute, cursor)
for row in tail(source):
insert(row)
def test_retrieve_ordered_by_time(self):
table_a = self.data.partition_a.table()
with closing(self.conn.cursor()) as cursor:
eq_(row_count(cursor, table_a), 3)
table_names = [table_a.name]
start = self.data.timestamp_1
end = self.data.timestamp_1
entity = self.data.entities[1]
entities = [entity.id]
columns = [
Column(table_a, "CellID"),
Column(table_a, "CCR"),
Column(table_a, "CCRatts"),
Column(table_a, "Drops")]
r = retrieve_orderedby_time(self.conn, SCHEMA, table_names, columns,
entities, start, end)
eq_(len(r), 1)
first_result = head(r)
entity_id, timestamp, c1, c2, c3, c4 = first_result
eq_(entity_id, entity.id)
eq_(c4, 18)
def test_retrieve_from_v4_trendstore(self):
table_names = [self.data.partition_a.table().name]
start = self.data.timestamp_1
end = self.data.timestamp_1
entity = self.data.entities[1]
entities = [entity.id]
column_names = [
"CellID",
"CCR",
"CCRatts",
"Drops"]
create_column = partial(Column, self.data.partition_a.table())
columns = map(create_column, column_names)
r = retrieve(self.conn, SCHEMA, table_names, columns, entities, start, end)
eq_(len(r), 1)
first_result = head(r)
entity_id, timestamp, c1, c2, c3, c4 = first_result
eq_(entity_id, entity.id)
eq_(c4, 18)
def get_column_srid(cursor, table_name, column_name):
query = (
"SELECT srid "
"FROM geometry_columns "
"WHERE f_geometry_column = %s "
"AND f_table_name = %s "
"AND f_table_schema = %s")
args = column_name, table_name, "gis"
cursor.execute(query, args)
return head(cursor.fetchone())
def create(self, cursor):
"""Create, initialize and return the attributestore."""
query = (
"INSERT INTO attribute_directory.attributestore"
"(datasource_id, entitytype_id) "
"VALUES (%s, %s) "
"RETURNING id")
args = self.datasource.id, self.entitytype.id
cursor.execute(query, args)
self.id = head(cursor.fetchone())
for attribute in self.attributes:
attribute.create(cursor)
return self.init(cursor)
def render_source(source):
"""
Renders a data 'source' in the form of a table-like object:
[
('column_1', 'column_2', 'column_3', ...),
(1, 2, 3,...),
(4, 5, 6,...),
...
]
"""
column_names = head(source)
column_align = ">" * len(column_names)
column_sizes = ["max"] * len(column_names)
rows = tail(source)
return render_table(column_names, column_align, column_sizes, rows)
def test_retrieve_multi_table_time(self):
tables = [self.data.partition_d_1.table(), self.data.partition_d_2.table()]
start = self.data.timestamp_1 - timedelta(seconds=60)
end = self.data.timestamp_2
entity = self.data.entities[1]
entities = [entity.id]
column_names = [
"counter_x"]
columns = map(Column, column_names)
with closing(self.conn.cursor()) as cursor:
r = retrieve(cursor, tables, columns, entities, start, end)
eq_(len(r), 2)
first_result = head(r)
entity_id, timestamp, c1 = first_result
eq_(entity_id, entity.id)
eq_(c1, 110)
def test_retrieve_from_v4_trendstore(conn):
plugin = get_plugin("trend")
data = TestData()
plugin_obj = plugin(conn, api_version=3)
with closing(conn.cursor()) as cursor:
clear_database(cursor)
data.load(cursor)
start = data.timestamp_1
end = data.timestamp_1
entity = data.entities[1]
entities = [entity.id]
column_names = [
"CellID",
"CCR",
"CCRatts",
"Drops"]
datasources = [data.datasource_a]
entitytype = data.entitytype
granularity = 900
r = plugin_obj.retrieve(datasources, granularity, entitytype,
column_names, entities, start, end)
eq_(len(r), 1)
first_result = head(r)
entity_id, timestamp, c1, c2, c3, c4 = first_result
eq_(entity_id, entity.id)
eq_(c4, 18)
def test_retrieve_multi_table_time(self):
table_d_1 = self.data.partition_d_1.table()
table_d_2 = self.data.partition_d_2.table()
table_names = [table_d_1.name, table_d_2.name]
start = self.data.timestamp_1 - timedelta(seconds=60)
end = self.data.timestamp_2
entity = self.data.entities[1]
entities = [entity.id]
column_names = [
"counter_x"]
columns = map(Column, column_names)
r = retrieve(self.conn, SCHEMA, table_names, columns, entities, start, end)
eq_(len(r), 2)
first_result = head(r)
entity_id, timestamp, c1 = first_result
eq_(entity_id, entity.id)
eq_(c1, 110)
def fetch_scalar(cursor):
"""Return the one scalar result from `cursor`."""
return head(cursor.fetchone())
def get_scalar(cursor):
return head(cursor.fetchone())
