def datastore_search(context, data_dict):
'''Search a datastore table.
:param resource_id: id or alias of the data that is going to be selected.
:type resource_id: string
:param filters: matching conditions to select.
:type filters: dictionary
:param q: full text query
:type q: string
:param plain: treat as plain text query (default: true)
:type plain: bool
:param language: language of the full text query (default: english)
:type language: string
:param limit: maximum number of rows to return (default: 100)
:type limit: int
:param offset: offset the number of rows
:type offset: int
:param fields: fields to return
(default: all fields in original order)
:type fields: list or comma separated string
:param sort: comma separated field names with ordering
eg: "fieldname1, fieldname2 desc"
:type sort: string
:returns: a dictionary containing the search parameters and the
search results.
keys: fields: same as datastore_create accepts
offset: query offset value
limit: query limit value
filters: query filters
total: number of total matching records
records: list of matching results
:rtype: dictionary
'''
res_id = _get_or_bust(data_dict, 'resource_id')
data_dict['connection_url'] = pylons.config['ckan.datastore.read_url']
resources_sql = sqlalchemy.text(u'SELECT 1 FROM "_table_metadata" WHERE name = :id')
results = db._get_engine(None, data_dict).execute(resources_sql, id=res_id)
res_exists = results.rowcount > 0
if not res_exists:
raise p.toolkit.ObjectNotFound(p.toolkit._(
'Resource "{0}" was not found.'.format(res_id)
))
p.toolkit.check_access('datastore_search', context, data_dict)
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
def datastore_search(context, data_dict):
'''Search a datastore table.
:param resource_id: id or alias of the data that is going to be selected.
:type resource_id: string
:param filters: matching conditions to select.
:type filters: dictionary
:param q: full text query
:type q: string
:param plain: treat as plain text query (default: true)
:type plain: bool
:param language: language of the full text query (default: english)
:type language: string
:param limit: maximum number of rows to return (default: 100)
:type limit: int
:param offset: offset the number of rows
:type offset: int
:param fields: fields to return
(default: all fields in original order)
:type fields: list or comma separated string
:param sort: comma separated field names with ordering
eg: "fieldname1, fieldname2 desc"
:type sort: string
:returns: a dictionary containing the search parameters and the
search results.
keys: fields: same as datastore_create accepts
offset: query offset value
limit: query limit value
filters: query filters
total: number of total matching records
records: list of matching results
:rtype: dictionary
'''
res_id = _get_or_bust(data_dict, 'resource_id')
data_dict['connection_url'] = pylons.config['ckan.datastore.read_url']
resources_sql = sqlalchemy.text(
u'SELECT 1 FROM "_table_metadata" WHERE name = :id')
results = db._get_engine(None, data_dict).execute(resources_sql, id=res_id)
res_exists = results.rowcount > 0
if not res_exists:
raise p.toolkit.ObjectNotFound(
p.toolkit._('Resource "{0}" was not found.'.format(res_id)))
p.toolkit.check_access('datastore_search', context, data_dict)
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
def datastore_search(context, data_dict):
'''Search a datastore table.
:param resource_id: id of the data that is going to be selected.
:type resource_id: string
:param filters: matching conditions to select.
:type filters: dictionary
:param q: full text query
:type q: string
:param limit: maximum number of rows to return (default: 100)
:type limit: int
:param offset: offset the number of rows
:type offset: int
:param fields: ordered list of fields to return
(default: all fields in original order)
:type fields: list of dictionaries
:param sort: comma separated field names with ordering
eg: "fieldname1, fieldname2 desc"
:type sort: string
:returns: a dictionary containing the search parameters and the
search results.
keys: fields: same as datastore_create accepts
offset: query offset value
limit: query limit value
filters: query filters
total: number of total matching records
records: list of matching results
:rtype: dictionary
'''
model = _get_or_bust(context, 'model')
id = _get_or_bust(data_dict, 'resource_id')
if not model.Resource.get(id):
raise p.toolkit.ObjectNotFound(p.toolkit._(
'Resource "{}" was not found.'.format(id)
))
p.toolkit.check_access('datastore_search', context, data_dict)
data_dict['connection_url'] = pylons.config['ckan.datastore_write_url']
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
def datastore_search(context, data_dict):
'''Search a datastore table.
:param resource_id: id of the data that is going to be selected.
:type resource_id: string
:param filters: matching conditions to select.
:type filters: dictionary
:param q: full text query
:type q: string
:param limit: maximum number of rows to return (default: 100)
:type limit: int
:param offset: offset the number of rows
:type offset: int
:param fields: ordered list of fields to return
(default: all fields in original order)
:type fields: list of dictionaries
:param sort: comma separated field names with ordering
eg: "fieldname1, fieldname2 desc"
:type sort: string
:returns: a dictionary containing the search parameters and the
search results.
keys: fields: same as datastore_create accepts
offset: query offset value
limit: query limit value
filters: query filters
total: number of total matching records
records: list of matching results
:rtype: dictionary
'''
model = _get_or_bust(context, 'model')
id = _get_or_bust(data_dict, 'resource_id')
if not model.Resource.get(id):
raise p.toolkit.ObjectNotFound(
p.toolkit._('Resource "{}" was not found.'.format(id)))
p.toolkit.check_access('datastore_search', context, data_dict)
data_dict['connection_url'] = pylons.config['ckan.datastore_write_url']
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
def datastore_search(context, data_dict):
'''Search a DataStore resource.
The datastore_search action allows you to search data in a resource.
DataStore resources that belong to private CKAN resource can only be
read by you if you have access to the CKAN resource and send the appropriate
authorization.
:param resource_id: id or alias of the resource to be searched against
:type resource_id: string
:param filters: matching conditions to select, e.g {"key1": "a", "key2": "b"} (optional)
:type filters: dictionary
:param q: full text query. If it's a string, it'll search on all fields on
each row. If it's a dictionary as {"key1": "a", "key2": "b"},
it'll search on each specific field (optional)
:type q: string or dictionary
:param distinct: return only distinct rows (optional, default: false)
:type distinct: bool
:param plain: treat as plain text query (optional, default: true)
:type plain: bool
:param language: language of the full text query (optional, default: english)
:type language: string
:param limit: maximum number of rows to return (optional, default: 100)
:type limit: int
:param offset: offset this number of rows (optional)
:type offset: int
:param fields: fields to return (optional, default: all fields in original order)
:type fields: list or comma separated string
:param sort: comma separated field names with ordering
e.g.: "fieldname1, fieldname2 desc"
:type sort: string
Setting the ``plain`` flag to false enables the entire PostgreSQL `full text search query language`_.
A listing of all available resources can be found at the alias ``_table_metadata``.
.. _full text search query language: http://www.postgresql.org/docs/9.1/static/datatype-textsearch.html#DATATYPE-TSQUERY
If you need to download the full resource, read :ref:`dump`.
**Results:**
The result of this action is a dictionary with the following keys:
:rtype: A dictionary with the following keys
:param fields: fields/columns and their extra metadata
:type fields: list of dictionaries
:param offset: query offset value
:type offset: int
:param limit: query limit value
:type limit: int
:param filters: query filters
:type filters: list of dictionaries
:param total: number of total matching records
:type total: int
:param records: list of matching results
:type records: list of dictionaries
'''
schema = context.get('schema', dsschema.datastore_search_schema())
data_dict, errors = _validate(data_dict, schema, context)
if errors:
raise p.toolkit.ValidationError(errors)
res_id = data_dict['resource_id']
data_dict['connection_url'] = pylons.config['ckan.datastore.write_url']
resources_sql = sqlalchemy.text(u'''SELECT alias_of FROM "_table_metadata"
WHERE name = :id''')
results = db._get_engine(data_dict).execute(resources_sql, id=res_id)
# Resource only has to exist in the datastore (because it could be an alias)
if not results.rowcount > 0:
raise p.toolkit.ObjectNotFound(
p.toolkit._('Resource "{0}" was not found.'.format(res_id)))
if not data_dict['resource_id'] in WHITELISTED_RESOURCES:
# Replace potential alias with real id to simplify access checks
resource_id = results.fetchone()[0]
if resource_id:
data_dict['resource_id'] = resource_id
p.toolkit.check_access('datastore_search', context, data_dict)
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
def datastore_search(context, data_dict):
'''Search a DataStore resource.
The datastore_search action allows you to search data in a resource.
DataStore resources that belong to private CKAN resource can only be
read by you if you have access to the CKAN resource and send the appropriate
authorization.
:param resource_id: id or alias of the resource to be searched against
:type resource_id: string
:param filters: matching conditions to select, e.g {"key1": "a", "key2": "b"} (optional)
:type filters: dictionary
:param q: full text query. If it's a string, it'll search on all fields on
each row. If it's a dictionary as {"key1": "a", "key2": "b"},
it'll search on each specific field (optional)
:type q: string or dictionary
:param distinct: return only distinct rows (optional, default: false)
:type distinct: bool
:param plain: treat as plain text query (optional, default: true)
:type plain: bool
:param language: language of the full text query (optional, default: english)
:type language: string
:param limit: maximum number of rows to return (optional, default: 100)
:type limit: int
:param offset: offset this number of rows (optional)
:type offset: int
:param fields: fields to return (optional, default: all fields in original order)
:type fields: list or comma separated string
:param sort: comma separated field names with ordering
e.g.: "fieldname1, fieldname2 desc"
:type sort: string
Setting the ``plain`` flag to false enables the entire PostgreSQL `full text search query language`_.
A listing of all available resources can be found at the alias ``_table_metadata``.
.. _full text search query language: http://www.postgresql.org/docs/9.1/static/datatype-textsearch.html#DATATYPE-TSQUERY
If you need to download the full resource, read :ref:`dump`.
**Results:**
The result of this action is a dictionary with the following keys:
:rtype: A dictionary with the following keys
:param fields: fields/columns and their extra metadata
:type fields: list of dictionaries
:param offset: query offset value
:type offset: int
:param limit: query limit value
:type limit: int
:param filters: query filters
:type filters: list of dictionaries
:param total: number of total matching records
:type total: int
:param records: list of matching results
:type records: list of dictionaries
'''
schema = context.get('schema', dsschema.datastore_search_schema())
data_dict, errors = _validate(data_dict, schema, context)
if errors:
raise p.toolkit.ValidationError(errors)
res_id = data_dict['resource_id']
data_dict['connection_url'] = pylons.config['ckan.datastore.write_url']
resources_sql = sqlalchemy.text(u'''SELECT alias_of FROM "_table_metadata"
WHERE name = :id''')
results = db._get_engine(data_dict).execute(resources_sql, id=res_id)
# Resource only has to exist in the datastore (because it could be an alias)
if not results.rowcount > 0:
raise p.toolkit.ObjectNotFound(p.toolkit._(
'Resource "{0}" was not found.'.format(res_id)
))
if not data_dict['resource_id'] in WHITELISTED_RESOURCES:
# Replace potential alias with real id to simplify access checks
resource_id = results.fetchone()[0]
if resource_id:
data_dict['resource_id'] = resource_id
p.toolkit.check_access('datastore_search', context, data_dict)
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
def datastore_search(context, data_dict):
'''Search a datastore table.
The datastore_search action allows a user to search data in a resource.
:param resource_id: id or alias of the resource to be searched against.
:type resource_id: string
:param filters: matching conditions to select, e.g {"key1": "a", "key2": "b"}
:type filters: dictionary
:param q: full text query
:type q: string
:param plain: treat as plain text query (default: true)
:type plain: bool
:param language: language of the full text query (default: english)
:type language: string
:param limit: maximum number of rows to return (default: 100)
:type limit: int
:param offset: offset this number of rows
:type offset: int
:param fields: fields to return (default: all fields in original order)
:type fields: list or comma separated string
:param sort: comma separated field names with ordering
e.g.: "fieldname1, fieldname2 desc"
:type sort: string
Setting the ``plain`` flag to false enables the entire PostgreSQL `full text search query language`_.
A listing of all available resources can be found at the alias ``_table_metadata``.
.. _full text search query language: http://www.postgresql.org/docs/9.1/static/datatype-textsearch.html#DATATYPE-TSQUERY
**Results:**
The result of this action is a dict with the following keys:
:rtype: A dictionary with the following keys
:param fields: fields/columns and their extra metadata
:type fields: list of dictionaries
:param offset: query offset value
:type offset: int
:param limit: query limit value
:type limit: int
:param filters: query filters
:type filters: list of dictionaries
:param total: number of total matching records
:type total: int
:param records: list of matching results
:type records: list of dictionaries
'''
if 'id' in data_dict:
data_dict['resource_id'] = data_dict['id']
res_id = _get_or_bust(data_dict, 'resource_id')
data_dict['connection_url'] = pylons.config.get('ckan.datastore.read_url',
pylons.config['ckan.datastore.write_url'])
resources_sql = sqlalchemy.text(u'SELECT 1 FROM "_table_metadata" WHERE name = :id')
results = db._get_engine(None, data_dict).execute(resources_sql, id=res_id)
res_exists = results.rowcount > 0
if not res_exists:
raise p.toolkit.ObjectNotFound(p.toolkit._(
'Resource "{0}" was not found.'.format(res_id)
))
p.toolkit.check_access('datastore_search', context, data_dict)
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
def datastore_search(context, data_dict):
'''Search a datastore table.
The datastore_search action allows a user to search data in a resource.
:param resource_id: id or alias of the resource to be searched against.
:type resource_id: string
:param filters: matching conditions to select, e.g {"key1": "a", "key2": "b"}
:type filters: dictionary
:param q: full text query
:type q: string
:param plain: treat as plain text query (default: true)
:type plain: bool
:param language: language of the full text query (default: english)
:type language: string
:param limit: maximum number of rows to return (default: 100)
:type limit: int
:param offset: offset this number of rows
:type offset: int
:param fields: fields to return (default: all fields in original order)
:type fields: list or comma separated string
:param sort: comma separated field names with ordering
e.g.: "fieldname1, fieldname2 desc"
:type sort: string
Setting the ``plain`` flag to false enables the entire PostgreSQL `full text search query language`_.
A listing of all available resources can be found at the alias ``_table_metadata``.
.. _full text search query language: http://www.postgresql.org/docs/9.1/static/datatype-textsearch.html#DATATYPE-TSQUERY
**Results:**
The result of this action is a dict with the following keys:
:rtype: A dictionary with the following keys
:param fields: fields/columns and their extra metadata
:type fields: list of dictionaries
:param offset: query offset value
:type offset: int
:param limit: query limit value
:type limit: int
:param filters: query filters
:type filters: list of dictionaries
:param total: number of total matching records
:type total: int
:param records: list of matching results
:type records: list of dictionaries
'''
if 'id' in data_dict:
data_dict['resource_id'] = data_dict['id']
res_id = _get_or_bust(data_dict, 'resource_id')
data_dict['connection_url'] = pylons.config.get(
'ckan.datastore.read_url', pylons.config['ckan.datastore.write_url'])
resources_sql = sqlalchemy.text(
u'SELECT 1 FROM "_table_metadata" WHERE name = :id')
results = db._get_engine(None, data_dict).execute(resources_sql, id=res_id)
res_exists = results.rowcount > 0
if not res_exists:
raise p.toolkit.ObjectNotFound(
p.toolkit._('Resource "{0}" was not found.'.format(res_id)))
p.toolkit.check_access('datastore_search', context, data_dict)
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
def datastore_search(context, data_dict):
'''Search a datastore table.
:param resource_id: id of the data that is going to be selected.
:type resource_id: string
:param filters: matching conditions to select.
:type filters: dictionary
:param q: full text query
:type q: string
:param plain: query is a plain text query (default: true)
:type plain: bool
:param lang: language of the full text query (default: english)
:type lang: string
:param limit: maximum number of rows to return (default: 100)
:type limit: int
:param offset: offset the number of rows
:type offset: int
:param fields: fields to return
(default: all fields in original order)
:type fields: list or comma separated string
:param sort: comma separated field names with ordering
eg: "fieldname1, fieldname2 desc"
:type sort: string
:returns: a dictionary containing the search parameters and the
search results.
keys: fields: same as datastore_create accepts
offset: query offset value
limit: query limit value
filters: query filters
total: number of total matching records
records: list of matching results
:rtype: dictionary
'''
model = _get_or_bust(context, 'model')
id = _get_or_bust(data_dict, 'resource_id')
data_dict['connection_url'] = pylons.config['ckan.datastore_read_url']
res_exists = model.Resource.get(id)
alias_exists = False
if not res_exists:
# assume id is an alias
alias_sql = ('select alias_of from "_table_metadata" '
"where name = '{0}'").format(id)
result = db._get_engine(None, data_dict).execute(alias_sql).fetchone()
if result:
alias_exists = model.Resource.get(result[0].strip('"'))
if not (res_exists or alias_exists):
raise p.toolkit.ObjectNotFound(p.toolkit._(
'Resource "{0}" was not found.'.format(id)
))
p.toolkit.check_access('datastore_search', context, data_dict)
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
def datastore_search(context, data_dict):
'''Search a datastore table.
:param resource_id: id of the data that is going to be selected.
:type resource_id: string
:param filters: matching conditions to select.
:type filters: dictionary
:param q: full text query
:type q: string
:param plain: query is a plain text query (default: true)
:type plain: bool
:param lang: language of the full text query (default: english)
:type lang: string
:param limit: maximum number of rows to return (default: 100)
:type limit: int
:param offset: offset the number of rows
:type offset: int
:param fields: fields to return
(default: all fields in original order)
:type fields: list or comma separated string
:param sort: comma separated field names with ordering
eg: "fieldname1, fieldname2 desc"
:type sort: string
:returns: a dictionary containing the search parameters and the
search results.
keys: fields: same as datastore_create accepts
offset: query offset value
limit: query limit value
filters: query filters
total: number of total matching records
records: list of matching results
:rtype: dictionary
'''
model = _get_or_bust(context, 'model')
id = _get_or_bust(data_dict, 'resource_id')
data_dict['connection_url'] = pylons.config['ckan.datastore_read_url']
res_exists = model.Resource.get(id)
alias_exists = False
if not res_exists:
# assume id is an alias
alias_sql = ('select alias_of from "_table_metadata" '
"where name = '{0}'").format(id)
result = db._get_engine(None, data_dict).execute(alias_sql).fetchone()
if result:
alias_exists = model.Resource.get(result[0].strip('"'))
if not (res_exists or alias_exists):
raise p.toolkit.ObjectNotFound(
p.toolkit._('Resource "{0}" was not found.'.format(id)))
p.toolkit.check_access('datastore_search', context, data_dict)
result = db.search(context, data_dict)
result.pop('id', None)
result.pop('connection_url')
return result
