def save_instance(instance, tenant_id, schema_id, table_id, instance_id):
fields = retrieve_schema_table_fields(tenant_id, schema_id, table_id)
instance = instance_object(id=instance_id, tenant_id=tenant_id, schema_id=schema_id, table_id=table_id, instance_data=instance)
DB.session.add(instance)
DB.session.commit()
save_unique_values(instance, tenant_id, schema_id, table_id, fields)
save_index_values(instance, tenant_id, schema_id, table_id, fields)
return instance
def retrieve_all_instances(tenant_id, schema_id, table_id, query_filters={}):
"""
"""
criteria = [Instance.tenant_id == tenant_id,
Instance.schema_id == schema_id,
Instance.table_id == table_id]
ext_criteria = []
if query_filters:
meta_fields = dict([(field.field_name, field) for field in retrieve_schema_table_fields(tenant_id, schema_id, table_id)])
index_fields = [field_name for field_name, field in meta_fields.items() if query_filters.has_key(field_name) and field.index_single]
non_index_fields = set(query_filters.keys()) - set(index_fields)
query_filters = dict([(field_name, set_field_type(meta_fields[field_name]).type(value)) for field_name, value in query_filters.items()])
ext_criteria = ( [add_index_query_filter(index_field, query_filters[index_field]) for index_field in index_fields] +
[add_query_filter(non_index, query_filters[non_index]) for non_index in non_index_fields] )
criteria = and_(or_(*ext_criteria), *criteria)
return Instance.query.filter(criteria).all()
def local_type(verifield, type_name):
""" Checks if a field conforms to the local table definition, which is basically a join/sub-object
:param type_name: URI of the tenant.schema.table Ids that would be reference of the object to validate against
:type type_name: URI
:returns: bool
"""
from polyglot.pyapi.meta import retrieve_schema_table_fields
from polyglot.pyapi.instance import create_instance_validators
from polyglot.models.schema import Instance
(tenant_id, schema_id, table_id) = type_name.split("::")
fields = retrieve_schema_table_fields(tenant_id, schema_id, table_id)
validators = Instance._validations
validators['instance_data'] = create_instance_validators(fields)
instance = Instance(**instance)
instance.validate(validators)
instance._validations = validators
return not((hasattr(instance, 'validation_errors')
and instance.validation_errors) \
or instance.instance_data.get('validation_errors', {}))
def get_table_fields(tenant_id, schema_id, table_id):
return unwrap_response(retrieve_schema_table_fields(tenant_id, schema_id, table_id))
