def analytics_query( self, # type: Cluster statement, # type: str, *options, # type: AnalyticsOptions **kwargs): # type: (...) -> AnalyticsResult """ Executes an Analytics query against the remote cluster and returns a AnalyticsResult with the results of the query. :param statement: the analytics statement to execute :param options: the optional parameters that the Analytics service takes based on the Analytics RFC. :return: An AnalyticsResult object with the results of the query or error message if the query failed on the server. :raise: :exc:`~.exceptions.AnalyticsException` errors associated with the analytics query itself. Also, any exceptions raised by the underlying platform - :class:`~.exceptions.TimeoutException` for example. """ # following the query implementation, but this seems worth revisiting soon self._check_for_shutdown() itercls = kwargs.pop('itercls', AnalyticsResult) opt = AnalyticsOptions() opts = list(options) for o in opts: if isinstance(o, AnalyticsOptions): opt = o opts.remove(o) return self._maybe_operate_on_an_open_bucket( CoreClient.analytics_query, AnalyticsException, opt.to_analytics_query(statement, *opts, **kwargs), itercls=itercls, err_msg='Analytics queries require an open bucket')
def test_query_positional_params(self): rows_attempt = self.try_n_times(10, 3, self.assertQueryReturnsRows, 'SELECT * FROM `{}` WHERE `type` = $1 LIMIT 1'.format( self.dataset_name), AnalyticsOptions(positional_parameters=["brewery"])) print(rows_attempt) return self.checkResult(rows_attempt, lambda result: self.assertEqual("brewery", result[0][self.dataset_name]['type']))
def test_query_named_parameters_override(self): rows_attempt = self.try_n_times(10, 3, self.assertQueryReturnsRows, "SELECT * FROM `{}` WHERE `type` = $btype LIMIT 1".format( self.dataset_name), AnalyticsOptions(named_parameters={ "btype": "jfjfjfjf"}), btype="brewery") return self.checkResult(rows_attempt, lambda result: self.assertEqual("brewery", result[0][self.dataset_name]['type']))
async def analytics_query(cluster): try: result = cluster.analytics_query( "SELECT a.* FROM `travel-sample`.inventory.airports a WHERE a.country = $country LIMIT 10", AnalyticsOptions(named_parameters={"country": "France"})) async for row in result: print("Found row: {}".format(row)) except CouchbaseException as ex: print(ex)
async def simple_query(cluster): try: result = cluster.analytics_query( "SELECT id, country FROM airports a WHERE a.country = $country LIMIT 10", AnalyticsOptions(named_parameters={"country": "France"})) async for row in result: print("Found row: {}".format(row)) except CompilationFailedException as ex: print(ex)
def test_bad_query_context(self): # test w/ no context result = self.cluster.analytics_query("SELECT * FROM beers LIMIT 2") with self.assertRaises(DatasetNotFoundException): result.rows() # test w/ bad scope q_context = 'default:`{}`.`{}`'.format(self.bucket_name, 'fake-scope') result = self.cluster.analytics_query( "SELECT * FROM beers LIMIT 2", AnalyticsOptions(query_context=q_context)) with self.assertRaises(DataverseNotFoundException): result.rows()
def test_cluster_query_context(self): q_context = 'default:{}'.format(self.dataverse_fqdn) # test with QueryOptions a_opts = AnalyticsOptions(query_context=q_context) result = self.cluster.analytics_query( "SELECT * FROM beers LIMIT 2", a_opts) self.assertRows(result, 2) # test with kwargs result = self.cluster.analytics_query( "SELECT * FROM beers LIMIT 2", query_context=q_context) self.assertRows(result, 2)
def test_bad_scope_query(self): scope = self.bucket.scope(self.beer_sample_collections.scope) q_context = 'default:`{}`.`{}`'.format(self.bucket_name, 'fake-scope') result = scope.analytics_query("SELECT * FROM beers LIMIT 2", AnalyticsOptions(query_context=q_context)) with self.assertRaises(DataverseNotFoundException): result.rows() q_context = 'default:`{}`.`{}`'.format( 'fake-bucket', self.beer_sample_collections.scope) result = scope.analytics_query("SELECT * FROM beers LIMIT 2", query_context=q_context) with self.assertRaises(DataverseNotFoundException): result.rows()
def test_scope_query_with_named_params_in_options(self): scope = self.bucket.scope(self.beer_sample_collections.scope) result = scope.analytics_query("SELECT * FROM beers WHERE META().id LIKE $brewery LIMIT 1", AnalyticsOptions(named_parameters={'brewery': '21st_amendment%'})) self.assertRows(result, 1)
def to_analytics_options(self, **kwargs): final_opts = {**self, **kwargs} return AnalyticsOptions( **{k: v for k, v in final_opts.items() if k in self.OPTION_KEYS})
def _to_analytics_options(option # type: BaseAnalyticsIndexManagerOptions ): return option.to_analytics_options() if option else AnalyticsOptions()
from twisted.internet import reactor from txcouchbase.cluster import TxCluster from couchbase.cluster import ClusterOptions from couchbase.auth import PasswordAuthenticator from couchbase.analytics import AnalyticsOptions def handle_query_results(result): for r in result.rows(): print("query row: {}".format(r)) reactor.stop() cluster = TxCluster( "couchbase://localhost", ClusterOptions(PasswordAuthenticator("Administrator", "password"))) # create a bucket object bucket = cluster.bucket("travel-sample") # create a collection object cb = bucket.default_collection() d = cluster.analytics_query( "SELECT id, country FROM airports a WHERE a.country = $country LIMIT 10", AnalyticsOptions(named_parameters={"country": "France"})) d.addCallback(handle_query_results) reactor.run() # end::simple_query[]