Utilisez BigQuery depuis Python.

Utilisez BigQuery avec Python.

BigQuery est un environnement d'analyse de données très rapide fourni par Google. Il semble que tout soit distribué et traité sur des milliers de machines, et il semble que seul Google puisse le faire.

J'ai eu une connexion et j'ai eu l'occasion d'évaluer BigQuery. C'était assez rapide quand je l'ai touché. J'ai essayé la méthode de toucher de python, donc je veux la partager.

Préparation préalable

Correction du 14/09/2015

Même si vous ne prenez pas la méthode ci-dessous

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

Il semble y avoir une bibliothèque appelée. Je laisserai la description ci-dessous pour référence.

Arrangement environnemental

Je l'ai essayé sur ubuntu 13.10.

Pour l'utiliser avec python, installez la bibliothèque suivante. Entrez «pip» à l'avance.

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

Générez l'authentification Oauth pour bigquery et obtenez la clé pour p12.

Créez une clé client à partir de l'authentification de la console développeur de Google. Un fichier clé appelé p12 sera créé, alors utilisez-le.

WS000000.JPG

Accès en utilisant python.

J'ai évoqué ce débordement de pile.

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

J'ai essayé les méthodes synchrones (sync) et asynchrones (asynchrones). L'environnement que j'ai essayé n'était pas très général car je l'ai essayé dans l'environnement de mon jeu de données vidéo Nico Nico. Apparemment, il semble correspondre normalement même en utilisant le japonais (utf-8).

#!/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()





Recommended Posts

Utilisez BigQuery depuis Python.
Utilisez Thingsspeak de Python
Utiliser fluentd de python
Utilisez MySQL depuis Python
Utiliser MySQL depuis Python
Utilisez mecab-ipadic-neologd de Python
Utilisez l'API e-Stat de Python
Utiliser la PNL Stanford Core à partir de Python
Lire et utiliser des fichiers Python à partir de Python
Utiliser de force Google Translate à partir de python
Utilisez l'API kabu Station® de Python
Utilisez l'API Flickr de Python
Utiliser le modèle entraîné fastText de Python
Utiliser l'API Google Analytics de Python
sql à sql
MeCab de Python
EC2 (Python3) -> BigQuery
Utiliser le type de données PostgreSQL (jsonb) à partir de Python
Utiliser le groupe d'API d'apprentissage automatique A3RT de Python
Je veux utiliser jar de python
Utilisez BigQuery à partir de votre bloc-notes Jupyter local
Utiliser l'API Google Cloud Vision de Python
Utiliser Django à partir d'un script Python local
Manipuler des tables BigQuery à partir d'un client Python
Utilisation des fonctions C ++ de python avec pybind11
Touchez MySQL depuis Python 3
Utilisez config.ini avec Python
Exploitez Filemaker depuis Python
[Python] Utiliser JSON avec Python
Firebase: utilisez Cloud Firestore et Cloud Storage depuis Python
Utiliser des dates en Python
Accéder à bitcoind depuis python
Changements de Python 3.0 à Python 3.5
Changements de Python 2 à Python 3.0
Étude de Python Hour7: Comment utiliser les classes
Python depuis ou import
Utiliser Valgrind avec Python
Utiliser mecab avec Python 3
Exécutez Python à partir d'Excel
Installer Python à partir de la source
Utiliser DynamoDB avec Python
[Bash] Obtenez la puissance de python de bash en utilisant la documentation ici
Exécuter des commandes depuis Python
Faites fonctionner le neutron de Python!
Utilisation méthodique du format [Python]
Utiliser python avec docker
Je veux utiliser le solveur ceres de python
Faire fonctionner LXC depuis Python
Utiliser le client LiquidTap Python ②
Manipuler riak depuis python
Forcer Python depuis Fortran
Utiliser le profileur en Python
Exécutez BigQuery à partir de Lambda
Utilisons différentes versions de SQLite3 de Python3!
Exécuter la commande depuis Python
Envelopper C ++ avec Cython pour une utilisation à partir de Python
Utilisez le module Python nghttp2 de Homebrew de Python de pyenv
[Python] Lire depuis Stdin
Utilisez Tor pour vous connecter depuis urllib2 [Python] [Mac]
Python: décompressez depuis l'entrée standard en utilisant zipfile
Utiliser le client LiquidTap Python ①