示例#1
0
 def create_stream(self, schema_name: str, stream_name: str,
                   columns: Any) -> None:
     if self.try_get_stream(schema_name, stream_name) is None:
         get_mapi_connection().create_stream(schema_name, stream_name,
                                             columns)
         metric_name = get_metric_name(schema_name, stream_name)
         self._cache[metric_name] = columns
示例#2
0
def flush(discovery, found_metrics, values_to_insert):
    if discovery:
        for metric, values in found_metrics.items():
            if not values['created']:
                tuples_array = map(
                    lambda x: (x['name'], {
                        'type': x['type'],
                        'isTag': x['isTag']
                    }), values['columns'])
                values['columns'] = OrderedDict(tuples_array)
                create_stream_from_influxdb_discovery_fast(
                    metric, values['columns'])
                values['created'] = True

    for metric, values in values_to_insert.items():
        # "COPY 2 RECORDS INTO test FROM STDIN;\n44444444|AL|1495544891\n55555555|JAFFRI"
        get_mapi_connection().insert_points_via_csv(metric, len(values),
                                                    '\n'.join(values))
示例#3
0
    def get_all_streams_details(self) -> List[Dict[str, Any]]:
        database_streams = get_mapi_connection().get_database_streams()

        for entry in database_streams:
            next_metric_name = get_metric_name(entry['schema'],
                                               entry['stream'])
            cached_metric = self._cache.get(next_metric_name, None)
            if cached_metric is None:
                self._cache[next_metric_name] = entry['columns']

        return database_streams
示例#4
0
    def get_stream_details_by_schema(self, schema_name: str,
                                     stream_name: str) -> Dict[str, Any]:
        metric_name = get_metric_name(schema_name, stream_name)

        cached_metric = self._cache.get(metric_name, None)
        if cached_metric is None:
            cached_metric = get_mapi_connection().get_single_database_stream(
                schema_name, stream_name)
            self._cache[metric_name] = cached_metric['columns']

        return cached_metric
示例#5
0
 def insert_into_stream(self, schema_name: str, stream_name: str,
                        records: str) -> None:
     get_mapi_connection().insert_points_via_insertinto(
         schema_name, stream_name, records)
示例#6
0
 def delete_stream(self, schema_name: str, stream_name: str) -> None:
     metric_name = get_metric_name(schema_name, stream_name)
     self._cache.pop(metric_name, None)
     get_mapi_connection().delete_stream(schema_name, stream_name)