Verwenden Sie BigQuery aus Python.

Verwenden Sie BigQuery mit Python.

BigQuery ist eine sehr schnelle Datenanalyseumgebung, die von Google bereitgestellt wird. Es scheint, dass alles auf Tausenden von Computern verteilt und verarbeitet wird, und es scheint, dass nur Google dies tun kann.

Ich hatte eine Verbindung und hatte die Möglichkeit, BigQuery zu evaluieren. Es war ziemlich schnell, als ich es berührte. Ich habe die Methode zum Berühren von Python ausprobiert, daher möchte ich sie teilen.

Vorbereitungen

• Stellen Sie es nur für BigQuery zur Verfügung.
• Möglicherweise können Sie es nicht verwenden, ohne die Abrechnung festzulegen.
• Aktivieren Sie den Zugriff auf die BigQuery-API.

14.09.2015 Korrektur

Auch wenn Sie die unten stehende Methode nicht anwenden

https://github.com/tylertreat/BigQuery-Python

Es scheint eine Bibliothek namens zu geben. Ich werde die Beschreibung unten als Referenz hinterlassen.

Umweltvereinbarung

Ich habe es auf Ubuntu 13.10 versucht.

Installieren Sie die folgende Bibliothek, um sie mit Python zu verwenden. Geben Sie im Voraus pip ein.

sudo pip install --upgrade google-api-python-client
sudo pip install --upgrade oauth2client
sudo pip install httplib

Generieren Sie die Oauth-Authentifizierung für Bigquery und holen Sie sich den Schlüssel für p12.

Erstellen Sie einen Client-Schlüssel über die Authentifizierung der Google-Entwicklerkonsole. Eine Schlüsseldatei mit dem Namen p12 wird erstellt. Verwenden Sie sie daher.

Zugriff mit Python.

Ich bezog mich auf diesen Stapel Überlauf.

http://stackoverflow.com/questions/13212991/how-to-query-bigquery-programmatically-from-python-without-end-user-interaction

Ich habe sowohl synchrone (Sync) als auch asynchrone (Async) Methoden ausprobiert. Die Umgebung, die ich ausprobiert habe, war nicht sehr allgemein, da ich sie in der Umgebung meines Nico Nico-Videodatensatzes ausprobiert habe. Anscheinend scheint es auch bei Verwendung von Japanisch (utf-8) normal zu passen.

#!/usr/bin/python
# -*- coding:utf-8 -*-
import httplib2
import logging
import time
from apiclient.discovery import build
from oauth2client.client import SignedJwtAssertionCredentials
import pprint

# REPLACE WITH YOUR Project ID
PROJECT_NUMBER = 'XXXXXXXXXXXX'
# REPLACE WITH THE SERVICE ACCOUNT EMAIL FROM GOOGLE DEV CONSOLE
SERVICE_ACCOUNT_EMAIL ='[email protected]'
KEYFILE='xxxxxxxxxxxxxxxx.p12'


class BQC(object):
    def __init__(self):
        f = file(KEYFILE, 'rb')
        self.key = f.read()
        f.close()

    def _credential(self):
        credentials = SignedJwtAssertionCredentials(
            SERVICE_ACCOUNT_EMAIL,
            self.key,
            scope='https://www.googleapis.com/auth/bigquery')

        http = httplib2.Http()
        http = credentials.authorize(http)

        service = build('bigquery', 'v2')
        return http,service

    def datalist(self,service,http):
        datasets = service.datasets()
        response = datasets.list(projectId=PROJECT_NUMBER).execute(http)
        print('Dataset list:\n')
        for dataset in response['datasets']:
            print("%s\n" % dataset['id'])

    def show_result(self,result):
        pprint.pprint(result)
        print 'Query Results:'
        for row in result['rows']:
            result_row = []
            for field in row['f']:
                if field['v']:
                    result_row.append(field['v'])
            print ('\t').join(result_row)



    def sync_method(self,service,http):
        q='SELECT *  FROM [nicodata_test.videoinfo] WHERE title like "%{}%" LIMIT 10;'.format(u'Vocaloid'.encode('utf-8'))
        print q
        #q='SELECT TOP(title, 30) as title, COUNT(*) as revision_count FROM [publicdata:samples.wikipedia] WHERE wp_namespace = 0;'
        query_request=service.jobs()
        query_data={'query':q}
        query_response = query_request.query(projectId=PROJECT_NUMBER,
                                             body=query_data).execute(http)
    def async_method(self,service,http):
        q='SELECT *  FROM [nicodata_test.videoinfo] WHERE title like "%{}%" LIMIT 90;'.format(u'Vocaloid'.encode('utf-8'))
        q='SELECT *  FROM [nicodata_test.comment_data] WHERE comment like "%{}%" LIMIT 90;'.format(u'Vocaloid'.encode('utf-8'))

        print q
        query_request=service.jobs()
        query_data={'query':q}
        query_data = {
            'configuration': {
                'query': {
                    'query': q,
                    }
                }
            }

        ft=time.time()
        insertResponse = query_request.insert(projectId=PROJECT_NUMBER,
                                         body=query_data).execute(http)
        print 'start query diff={}'.format(time.time()-ft)
        while True:
            print 'stat_get'
            ft2=time.time()
            status = query_request.get(projectId=PROJECT_NUMBER, jobId=insertResponse['jobReference']['jobId']).execute(http)
            print 'end get diff={}'.format(time.time()-ft2)
            currentStatus = status['status']['state']
            if 'DONE' == currentStatus:
                print 'sql done'
                break
            else:
                print 'Waiting for the query to complete...'
                print 'Current status: ' + currentStatus
                print time.ctime()
                time.sleep(0.1)
        currentRow = 0
        queryReply = query_request.getQueryResults(
            projectId=PROJECT_NUMBER,
            jobId=insertResponse['jobReference']['jobId'],
            startIndex=currentRow).execute(http)

        while(('rows' in queryReply) and currentRow < queryReply['totalRows']):
            #self.show_result(queryReply)
            currentRow += len(queryReply['rows'])
            queryReply = query_request.getQueryResults(
                projectId=PROJECT_NUMBER,
                jobId=queryReply['jobReference']['jobId'],
                startIndex=currentRow).execute(http)

        print currentRow
    def show(self):
        http,service=self._credential()
        #self.datalist(service,http)
        #result=self.sync_method(service,http)
        result=self.async_method(service,http)
        #self.show_result(result)
def main():
    bqc=BQC()
    bqc.show()

if __name__=='__main__':main()