def test_querybuilder_insert():
data = {'foo': 'FOO', 'bar': 'BAR'}
query = querybuilder.insert('mytable', sorted(data.keys()))
assert query == ('INSERT INTO "mytable" ("bar", "foo") '
'VALUES (%(bar)s, %(foo)s) RETURNING "id"')
query = querybuilder.insert('mytable',
sorted(data.keys()),
table_key='myid')
assert query == ('INSERT INTO "mytable" ("bar", "foo") '
'VALUES (%(bar)s, %(foo)s) RETURNING "myid"')
def resource_data_create(self, stream, metadata=None, mimetype=None):
"""Create resource data from a stream"""
resource_hash = hashlib.sha1()
with self.db, self.db.cursor() as cur:
lobj = self.db.lobject(oid=0, mode='wb')
oid = lobj.oid
for chunk in file_read_chunks(stream):
lobj.write(chunk)
resource_hash.update(chunk)
lobj.close()
data = {
'ctime': datetime.now(),
'mtime': datetime.now(),
'metadata': json.dumps(metadata),
'mimetype': mimetype or 'application/octet-stream',
'data_oid': oid,
'hash': 'sha1:{0}'.format(resource_hash.hexdigest()),
}
query = querybuilder.insert('resource_data', data)
cur.execute(query, data)
resource_data_id = cur.fetchone()[0]
return resource_data_id
def resource_data_create(self, stream, metadata=None, mimetype=None):
"""Create resource data from a stream"""
resource_hash = hashlib.sha1()
with self.db, self.db.cursor() as cur:
lobj = self.db.lobject(oid=0, mode='wb')
oid = lobj.oid
for chunk in file_read_chunks(stream):
lobj.write(chunk)
resource_hash.update(chunk)
lobj.close()
data = {
'ctime': datetime.now(),
'mtime': datetime.now(),
'metadata': json.dumps(metadata),
'mimetype': mimetype or 'application/octet-stream',
'data_oid': oid,
'hash': 'sha1:{0}'.format(resource_hash.hexdigest()),
}
query = querybuilder.insert('resource_data', data)
cur.execute(query, data)
resource_data_id = cur.fetchone()[0]
return resource_data_id
def add_dataset_resource(self, dataset_id, resource_id, order=0):
data = {
'dataset_id': dataset_id,
'resource_id': resource_id,
'order': order}
query = querybuilder.insert(
'dataset_resource', data=data, table_key=None)
with self.db, self.db.cursor() as cur:
cur.execute(query, data)
def _dsres_create(self, name, obj):
data = {
'configuration': json.dumps(obj),
'ctime': datetime.now(),
'mtime': datetime.now(),
}
query = querybuilder.insert(name, data)
with self.db, self.db.cursor() as cur:
cur.execute(query, data)
return cur.fetchone()[0]
def _dsres_create(self, name, obj):
data = {
'configuration': json.dumps(obj),
'ctime': datetime.now(),
'mtime': datetime.now(),
}
query = querybuilder.insert(name, data)
with self.db, self.db.cursor() as cur:
cur.execute(query, data)
return cur.fetchone()[0]
def add_dataset_resource(self, dataset_id, resource_id, order=0):
data = {
'dataset_id': dataset_id,
'resource_id': resource_id,
'order': order
}
query = querybuilder.insert('dataset_resource',
data=data,
table_key=None)
with self.db, self.db.cursor() as cur:
cur.execute(query, data)
def post_resource_index():
"""
We got some data to be stored as a new resource.
Then we want to return 201 + URL of the created resource in the
Location: header.
"""
content_type = "application/octet-stream"
if request.headers.get("Content-type"):
content_type, _ = parse_header(request.headers["Content-type"])
# First, store the data in a PostgreSQL large object
with db, db.cursor() as cur:
lobj = db.lobject(oid=0, mode="wb")
oid = lobj.oid
lobj.write(request.data)
lobj.close()
resource_hash = "sha1:" + hashlib.sha1(request.data).hexdigest()
data = dict(
metadata="{}",
auto_metadata="{}",
mimetype=content_type,
data_oid=oid,
ctime=datetime.datetime.utcnow(),
mtime=datetime.datetime.utcnow(),
hash=resource_hash,
)
# Then, create a record for the metadata
query = querybuilder.insert("resource", data)
cur.execute(query, data)
resource_id = cur.fetchone()[0]
# Last, retun 201 + Location: header
location = url_for(".get_resource_data", resource_id=resource_id)
return "", 201, {"Location": location}
def post_resource_index():
"""
We got some data to be stored as a new resource.
Then we want to return 201 + URL of the created resource in the
Location: header.
"""
content_type = 'application/octet-stream'
if request.headers.get('Content-type'):
content_type, _ = parse_header(request.headers['Content-type'])
# First, store the data in a PostgreSQL large object
with db, db.cursor() as cur:
lobj = db.lobject(oid=0, mode='wb')
oid = lobj.oid
lobj.write(request.data)
lobj.close()
resource_hash = 'sha1:' + hashlib.sha1(request.data).hexdigest()
data = dict(metadata='{}',
auto_metadata='{}',
mimetype=content_type,
data_oid=oid,
ctime=datetime.datetime.utcnow(),
mtime=datetime.datetime.utcnow(),
hash=resource_hash)
# Then, create a record for the metadata
query = querybuilder.insert('resource', data)
cur.execute(query, data)
resource_id = cur.fetchone()[0]
# Last, retun 201 + Location: header
location = url_for('.get_resource_data', resource_id=resource_id)
return '', 201, {'Location': location}
def test_querybuilder_sanity_checks():
with pytest.raises(ValueError):
querybuilder.insert('invalid table name', {'foo': 'bar'})
with pytest.raises(ValueError):
querybuilder.insert('mytable', {'invalid field name': 'bar'})
with pytest.raises(ValueError):
querybuilder.insert('mytable', {'foo': 'bar'}, table_key='invalid key')
# -------------------- Update --------------------
with pytest.raises(ValueError):
querybuilder.update('invalid table name', {'foo': 'bar'})
with pytest.raises(ValueError):
querybuilder.update('mytable', {'invalid field name': 'bar'})
with pytest.raises(ValueError):
querybuilder.update('mytable', {'foo': 'bar'}, table_key='invalid key')
