Example #1
0
def find_within_distance_and_color(session, lat, lon, distance, color, fetch_size=20):
    # Find all points of color within a diameter of lat and lon
    query = """SELECT * FROM %s.%s WHERE solr_query='{"q":"color:%s", "fq":"+{!geofilt pt=%s,%s sfield=location d=%s}"}';""" \
            % (KEYSPACE, COLUMN_FAMILY, color, lat, lon, distance)
    statement = SimpleStatement(query)
    statement.fetch_size = fetch_size
    return session.execute(statement)
Example #2
0
        def paged_query_generator(cql_query, django_query):
            statement = SimpleStatement(str(cql_query._select_query()),
                                        consistency_level=ConsistencyLevel.ONE)

            if (hasattr(django_query, 'cassandra_meta')
                    and None is not django_query.cassandra_meta
                    and hasattr(django_query.cassandra_meta, 'fetch_size')):
                statement.fetch_size = django_query.cassandra_meta.fetch_size

            parameters = {}
            for where in cql_query._where:
                if isinstance(where.value, Token):
                    value = where.value.value
                    if 1 == len(value):
                        value = value[0]

                else:
                    value = where.value

                parameters[str(where.query_value.context_id)] = value

            django_query.connection.session.row_factory = (
                ordered_dict_factory)

            results = django_query.connection.session.execute(
                statement, parameters)

            for row in results:
                for key, value in cql_query._deferred_values.iteritems():
                    row[key] = value

                yield row
Example #3
0
def find_within_distance_sorted(session, lat, lon, distance, fetch_size=20):
    # Find all points of color within a diameter of lat and lon
    # Not supported yet via CQL, need to use HTTP interface (DSP-5975)
    # http://localhost:8983/solr/geo.geo/select?wt=json&indent=true&fl=key,color&q=*:*&sfield=location&pt=37.7752,-122.4232&sort=geodist()%20asc&fl=_dist_:geodist(),key,color
    query = """SELECT * FROM %s.%s WHERE solr_query='{"q":"*:*", "fq":"+{!geofilt pt=%s,%s sfield=location d=%s}", "sort":"geodist(location,%s,%s) asc"}';""" \
            % (KEYSPACE, COLUMN_FAMILY, lat, lon, distance, lat, lon)
    statement = SimpleStatement(query)
    statement.fetch_size = fetch_size
    return session.execute(statement)
Example #4
0
def find_within_distance(session, lat, lon, distance, fetch_size=20):
    # Find all points within a diameter of lat and lon
    # http://localhost:8983/solr/geo.geo/select?wt=json&indent=true&q=*:*&fq={!geofilt%20pt=37.7752,-122.4232%20sfield=location%20d=5000}
    query = """SELECT * FROM %s.%s WHERE solr_query='{"q":"*:*", "fq":"{!geofilt pt=%s,%s sfield=location d=%s}"}';""" \
            % (KEYSPACE, COLUMN_FAMILY, lat, lon, distance)

    statement = SimpleStatement(query)
    statement.fetch_size = fetch_size
    return session.execute(statement)
Example #5
0
        def paged_query_generator(
            cql_query,
            django_query
        ):
            statement = SimpleStatement(
                str(cql_query._select_query()),
                consistency_level=ConsistencyLevel.ONE
            )

            if (
                hasattr(
                    django_query,
                    'cassandra_meta'
                ) and None is not django_query.cassandra_meta and
                hasattr(
                    django_query.cassandra_meta,
                    'fetch_size'
                )
            ):
                statement.fetch_size = django_query.cassandra_meta.fetch_size

            parameters = {}
            for where in cql_query._where:
                if isinstance(where.value, Token):
                    value = where.value.value
                    if 1 == len(value):
                        value = value[0]

                else:
                    value = where.value

                parameters[
                    str(where.query_value.context_id)
                ] = value

            django_query.connection.session.row_factory = (
                ordered_dict_factory
            )

            results = django_query.connection.session.execute(
                statement,
                parameters
            )

            for row in results:
                for key, value in cql_query._deferred_values.iteritems():
                    row[key] = value

                yield row
    def test_fetch_size(self):
        """
        Ensure per-statement fetch_sizes override the default fetch size.
        """
        statements_and_params = zip(cycle(["INSERT INTO test3rf.test (k, v) VALUES (%s, 0)"]),
                                    [(i, ) for i in range(100)])
        execute_concurrent(self.session, list(statements_and_params))

        prepared = self.session.prepare("SELECT * FROM test3rf.test")

        self.session.default_fetch_size = 10
        result = self.session.execute(prepared, [])
        self.assertTrue(result.has_more_pages)

        self.session.default_fetch_size = 2000
        result = self.session.execute(prepared, [])
        self.assertFalse(result.has_more_pages)

        self.session.default_fetch_size = None
        result = self.session.execute(prepared, [])
        self.assertFalse(result.has_more_pages)

        self.session.default_fetch_size = 10

        prepared.fetch_size = 2000
        result = self.session.execute(prepared, [])
        self.assertFalse(result.has_more_pages)

        prepared.fetch_size = None
        result = self.session.execute(prepared, [])
        self.assertFalse(result.has_more_pages)

        prepared.fetch_size = 10
        result = self.session.execute(prepared, [])
        self.assertTrue(result.has_more_pages)

        prepared.fetch_size = 2000
        bound = prepared.bind([])
        result = self.session.execute(bound, [])
        self.assertFalse(result.has_more_pages)

        prepared.fetch_size = None
        bound = prepared.bind([])
        result = self.session.execute(bound, [])
        self.assertFalse(result.has_more_pages)

        prepared.fetch_size = 10
        bound = prepared.bind([])
        result = self.session.execute(bound, [])
        self.assertTrue(result.has_more_pages)

        bound.fetch_size = 2000
        result = self.session.execute(bound, [])
        self.assertFalse(result.has_more_pages)

        bound.fetch_size = None
        result = self.session.execute(bound, [])
        self.assertFalse(result.has_more_pages)

        bound.fetch_size = 10
        result = self.session.execute(bound, [])
        self.assertTrue(result.has_more_pages)

        s = SimpleStatement("SELECT * FROM test3rf.test", fetch_size=None)
        result = self.session.execute(s, [])
        self.assertFalse(result.has_more_pages)

        s = SimpleStatement("SELECT * FROM test3rf.test")
        result = self.session.execute(s, [])
        self.assertTrue(result.has_more_pages)

        s = SimpleStatement("SELECT * FROM test3rf.test")
        s.fetch_size = None
        result = self.session.execute(s, [])
        self.assertFalse(result.has_more_pages)
    def test_fetch_size(self):
        """
        Ensure per-statement fetch_sizes override the default fetch size.
        """
        statements_and_params = zip(
            cycle(["INSERT INTO test3rf.test (k, v) VALUES (%s, 0)"]),
            [(i, ) for i in range(100)])
        execute_concurrent(self.session, list(statements_and_params))

        prepared = self.session.prepare("SELECT * FROM test3rf.test")

        self.session.default_fetch_size = 10
        result = self.session.execute(prepared, [])
        self.assertIsInstance(result, PagedResult)

        self.session.default_fetch_size = 2000
        result = self.session.execute(prepared, [])
        self.assertIsInstance(result, list)

        self.session.default_fetch_size = None
        result = self.session.execute(prepared, [])
        self.assertIsInstance(result, list)

        self.session.default_fetch_size = 10

        prepared.fetch_size = 2000
        result = self.session.execute(prepared, [])
        self.assertIsInstance(result, list)

        prepared.fetch_size = None
        result = self.session.execute(prepared, [])
        self.assertIsInstance(result, list)

        prepared.fetch_size = 10
        result = self.session.execute(prepared, [])
        self.assertIsInstance(result, PagedResult)

        prepared.fetch_size = 2000
        bound = prepared.bind([])
        result = self.session.execute(bound, [])
        self.assertIsInstance(result, list)

        prepared.fetch_size = None
        bound = prepared.bind([])
        result = self.session.execute(bound, [])
        self.assertIsInstance(result, list)

        prepared.fetch_size = 10
        bound = prepared.bind([])
        result = self.session.execute(bound, [])
        self.assertIsInstance(result, PagedResult)

        bound.fetch_size = 2000
        result = self.session.execute(bound, [])
        self.assertIsInstance(result, list)

        bound.fetch_size = None
        result = self.session.execute(bound, [])
        self.assertIsInstance(result, list)

        bound.fetch_size = 10
        result = self.session.execute(bound, [])
        self.assertIsInstance(result, PagedResult)

        s = SimpleStatement("SELECT * FROM test3rf.test", fetch_size=None)
        result = self.session.execute(s, [])
        self.assertIsInstance(result, list)

        s = SimpleStatement("SELECT * FROM test3rf.test")
        result = self.session.execute(s, [])
        self.assertIsInstance(result, PagedResult)

        s = SimpleStatement("SELECT * FROM test3rf.test")
        s.fetch_size = None
        result = self.session.execute(s, [])
        self.assertIsInstance(result, list)