def load_task():
client = Client()
job_config = LoadJobConfig()
schema_path = os.path.join(
dags_folder,
'resources/stages/raw/schemas/{task}.json'.format(task=task))
job_config.schema = read_bigquery_schema_from_file(schema_path)
job_config.source_format = SourceFormat.CSV if file_format == 'csv' else SourceFormat.NEWLINE_DELIMITED_JSON
if file_format == 'csv':
job_config.skip_leading_rows = 1
job_config.write_disposition = 'WRITE_TRUNCATE'
job_config.allow_quoted_newlines = allow_quoted_newlines
job_config.ignore_unknown_values = True
export_location_uri = 'gs://{bucket}/export'.format(
bucket=output_bucket)
uri = '{export_location_uri}/{task}/*.{file_format}'.format(
export_location_uri=export_location_uri,
task=task,
file_format=file_format)
table_ref = client.dataset(dataset_name_raw).table(task)
load_job = client.load_table_from_uri(uri,
table_ref,
job_config=job_config)
submit_bigquery_job(load_job, job_config)
assert load_job.state == 'DONE'
def _load_to_bq(self, client, dataset, table_name, table_schema,
table_config, key_props, metadata_columns, truncate, rows):
logger = self.logger
partition_field = table_config.get("partition_field", None)
cluster_fields = table_config.get("cluster_fields", None)
force_fields = table_config.get("force_fields", {})
schema = build_schema(table_schema,
key_properties=key_props,
add_metadata=metadata_columns,
force_fields=force_fields)
load_config = LoadJobConfig()
load_config.ignore_unknown_values = True
load_config.schema = schema
if partition_field:
load_config.time_partitioning = bigquery.table.TimePartitioning(
type_=bigquery.table.TimePartitioningType.DAY,
field=partition_field)
if cluster_fields:
load_config.clustering_fields = cluster_fields
load_config.source_format = SourceFormat.NEWLINE_DELIMITED_JSON
if truncate:
logger.info(f"Load {table_name} by FULL_TABLE (truncate)")
load_config.write_disposition = WriteDisposition.WRITE_TRUNCATE
else:
logger.info(f"Appending to {table_name}")
load_config.write_disposition = WriteDisposition.WRITE_APPEND
logger.info("loading {} to BigQuery".format(table_name))
load_job = None
try:
load_job = client.load_table_from_file(rows,
dataset.table(table_name),
job_config=load_config,
rewind=True)
logger.info("loading job {}".format(load_job.job_id))
job = load_job.result()
logger.info(job._properties)
return job
except google_exceptions.BadRequest as err:
logger.error("failed to load table {} from file: {}".format(
table_name, str(err)))
if load_job and load_job.errors:
reason = err.errors[0]["reason"]
messages = [f"{err['message']}" for err in load_job.errors]
logger.error("reason: {reason}, errors:\n{e}".format(
reason=reason, e="\n".join(messages)))
err.message = f"reason: {reason}, errors: {';'.join(messages)}"
raise err
def loadDataFromCSV(tablename, global_dataset_ref, filename):
schema = getTableSchema(tablename, global_dataset_ref)
table_ref = global_dataset_ref.table(tablename)
load_config = LoadJobConfig()
load_config.source_format = bigquery.SourceFormat.CSV
load_config.schema = schema
load_config.autodetect = True
load_config.allow_quoted_newlines = True
load_config.encoding = 'UTF-8'
try:
with open(filename, 'rb') as readable:
job = bigquery_client.load_table_from_file(readable,
table_ref,
location='US',
job_config=load_config)
except Exception as e:
print("Error")
print(e)
job.result()
print('Loaded {} rows into {}:{}.'.format(job.output_rows,
global_dataset_ref,
table_ref.table_id))
return
# Testing
# if __name__ == '__main__':
# datasetname = 'Testing'
# tablename = 'SOViews'
# sqlquery = '''SELECT CONCAT(
# 'https://stackoverflow.com/questions/',
# CAST(id as STRING)) as url,
# view_count
# FROM `bigquery-public-data.stackoverflow.posts_questions`
# WHERE tags like '%google-bigquery%'
# ORDER BY view_count DESC
# LIMIT 10'''
#createDataset(datasetname) #Successfully tested this code 2018-09-24
# global_dataset_ref = getDataset(datasetname) #Successfully tested this code 2018-09-24
#createTable(tablename, global_dataset_ref) #Successfully tested this code 2018-09-24
# getTable(tablename, global_dataset_ref) #Successfully tested this code 2018-09-24
# runBigQueryQuery(sqlquery) #Successfully tested this code 2018-09-24
#loadDataFromCSV(tablename, global_dataset_ref) #Successfully tested this code 2018-09-24
def DTSTableDefinition_to_BQLoadJobConfig(dts_tabledef):
"""
https://cloud.google.com/bigquery/docs/reference/data-transfer/partner/rpc/google.cloud.bigquery.datatransfer.v1#tabledefinition
TO
https://googlecloudplatform.github.io/google-cloud-python/latest/bigquery/reference.html#google.cloud.bigquery.job.LoadJob
:param dts_tabledef:
:return:
"""
from bq_dts import rest_client
job_config = LoadJobConfig()
dts_schema = RPCRecordSchema_to_GCloudSchema(dts_tabledef['schema'])
job_config.schema = dts_schema
# BQ DTS does not provide controls for the following dispositions
job_config.create_disposition = bigquery.CreateDisposition.CREATE_IF_NEEDED
job_config.write_disposition = bigquery.WriteDisposition.WRITE_TRUNCATE
if 'format' in dts_tabledef:
dts_format = dts_tabledef['format']
source_format = rest_client.BQ_DTS_FORMAT_TO_BQ_SOURCE_FORMAT_MAP[
dts_format]
assert source_format is not None
job_config.source_format = source_format
if 'max_bad_records' in dts_tabledef:
job_config.max_bad_records = dts_tabledef['max_bad_records']
if 'encoding' in dts_tabledef:
dts_encoding = dts_tabledef['encoding']
job_config.encoding = rest_client.BQ_DTS_ENCODING_TO_BQ_ENCODING_MAP[
dts_encoding]
if 'csv_options' in dts_tabledef:
csv_opts = dts_tabledef['csv_options']
if 'field_delimiter' in csv_opts:
job_config.field_delimiter = csv_opts['field_delimiter']
if 'allow_quoted_newlines' in csv_opts:
job_config.allow_quoted_newlines = csv_opts[
'allow_quoted_newlines']
if 'quote_char' in csv_opts:
job_config.quote_character = csv_opts['quote_char']
if 'skip_leading_rows' in csv_opts:
job_config.skip_leading_rows = csv_opts['skip_leading_rows']
return job_config
def load_stage(dst_dataset: Dataset, bq_client: Client, bucket_name: str,
gcs_client: storage.Client) -> List[LoadJob]:
"""
Stage files from a bucket to a dataset
:param dst_dataset: reference to destination dataset object
:param bq_client: a BigQuery client object
:param bucket_name: the location in GCS containing the vocabulary files
:param gcs_client: a Cloud Storage client object
:return: list of completed load jobs
"""
blobs = list(gcs_client.list_blobs(bucket_name))
table_blobs = [_filename_to_table_name(blob.name) for blob in blobs]
missing_blobs = [
table for table in VOCABULARY_TABLES if table not in table_blobs
]
if missing_blobs:
raise RuntimeError(
f'Bucket {bucket_name} is missing files for tables {missing_blobs}'
)
load_jobs = []
for blob in blobs:
table_name = _filename_to_table_name(blob.name)
# ignore any non-vocabulary files
if table_name not in VOCABULARY_TABLES:
continue
destination = dst_dataset.table(table_name)
safe_schema = safe_schema_for(table_name)
job_config = LoadJobConfig()
job_config.schema = safe_schema
job_config.skip_leading_rows = 1
job_config.field_delimiter = FIELD_DELIMITER
job_config.max_bad_records = MAX_BAD_RECORDS
job_config.source_format = 'CSV'
job_config.quote_character = ''
source_uri = f'gs://{bucket_name}/{blob.name}'
load_job = bq_client.load_table_from_uri(source_uri,
destination,
job_config=job_config)
LOGGER.info(f'table:{destination} job_id:{load_job.job_id}')
load_jobs.append(load_job)
load_job.result()
return load_jobs
def push_bq():
for table in rows.keys():
table_ref = bigquery_client.dataset(dataset_id).table(table)
SCHEMA = build_schema(schemas[table])
load_config = LoadJobConfig()
load_config.schema = SCHEMA
load_config.source_format = SourceFormat.NEWLINE_DELIMITED_JSON
if truncate:
load_config.write_disposition = WriteDisposition.WRITE_TRUNCATE
rows[table].seek(0)
logger.info('loading {} to Bigquery.\n'.format(table))
load_job = bigquery_client.load_table_from_file(
rows[table], table_ref, job_config=load_config)
logger.info('loading job {}'.format(load_job.job_id))
logger.info(load_job.result())
rows[table] = TemporaryFile(mode='w+b')
def load_data(self, dataframe, dataset_id, table_id, chunksize):
from google.cloud.bigquery import LoadJobConfig
from six import BytesIO
destination_table = self.client.dataset(dataset_id).table(table_id)
job_config = LoadJobConfig()
job_config.write_disposition = 'WRITE_APPEND'
job_config.source_format = 'NEWLINE_DELIMITED_JSON'
rows = []
remaining_rows = len(dataframe)
total_rows = remaining_rows
self._print("\n\n")
for index, row in dataframe.reset_index(drop=True).iterrows():
row_json = row.to_json(force_ascii=False,
date_unit='s',
date_format='iso')
rows.append(row_json)
remaining_rows -= 1
if (len(rows) % chunksize == 0) or (remaining_rows == 0):
self._print("\rLoad is {0}% Complete".format(
((total_rows - remaining_rows) * 100) / total_rows))
body = '{}\n'.format('\n'.join(rows))
if isinstance(body, bytes):
body = body.decode('utf-8')
body = body.encode('utf-8')
body = BytesIO(body)
try:
self.client.load_table_from_file(
body, destination_table,
job_config=job_config).result()
except self.http_error as ex:
self.process_http_error(ex)
rows = []
self._print("\n")
def load_folder(dst_dataset: str, bq_client: BQClient, bucket_name: str,
prefix: str, gcs_client: GCSClient,
hpo_id: str) -> List[LoadJob]:
"""
Stage files from a bucket to a dataset
:param dst_dataset: Identifies the destination dataset
:param bq_client: a BigQuery client object
:param bucket_name: the bucket in GCS containing the archive files
:param prefix: prefix of the filepath URI
:param gcs_client: a Cloud Storage client object
:param hpo_id: Identifies the HPO site
:return: list of completed load jobs
"""
blobs = list(gcs_client.list_blobs(bucket_name, prefix=prefix))
load_jobs = []
for blob in blobs:
table_name = _filename_to_table_name(blob.name)
if table_name not in AOU_REQUIRED:
LOGGER.debug(f'Skipping file for {table_name}')
continue
schema = get_table_schema(table_name)
hpo_table_name = f'{hpo_id}_{table_name}'
fq_hpo_table = f'{bq_client.project}.{dst_dataset}.{hpo_table_name}'
destination = Table(fq_hpo_table, schema=schema)
destination = bq_client.create_table(destination)
job_config = LoadJobConfig()
job_config.schema = schema
job_config.skip_leading_rows = 1
job_config.source_format = 'CSV'
source_uri = f'gs://{bucket_name}/{blob.name}'
load_job = bq_client.load_table_from_uri(
source_uri,
destination,
job_config=job_config,
job_id_prefix=f"{__file__.split('/')[-1].split('.')[0]}_")
LOGGER.info(f'table:{destination} job_id:{load_job.job_id}')
load_jobs.append(load_job)
load_job.result()
return load_jobs
def persist_lines_job(project_id, dataset_id, lines=None, truncate=False, validate_records=True):
state = None
schemas = {}
key_properties = {}
tables = {}
rows = {}
errors = {}
bigquery_client = bigquery.Client(project=project_id)
# try:
# dataset = bigquery_client.create_dataset(Dataset(dataset_ref)) or Dataset(dataset_ref)
# except exceptions.Conflict:
# pass
for line in lines:
try:
msg = singer.parse_message(line)
except json.decoder.JSONDecodeError:
logger.error("Unable to parse:\n{}".format(line))
raise
if isinstance(msg, singer.RecordMessage):
if msg.stream not in schemas:
raise Exception(
"A record for stream {} was encountered before a corresponding schema".format(msg.stream))
schema = schemas[msg.stream]
if validate_records:
validate(msg.record, schema)
# NEWLINE_DELIMITED_JSON expects literal JSON formatted data, with a newline character splitting each row.
dat = bytes(json.dumps(msg.record) + '\n', 'UTF-8')
rows[msg.stream].write(dat)
# rows[msg.stream].write(bytes(str(msg.record) + '\n', 'UTF-8'))
state = None
elif isinstance(msg, singer.StateMessage):
logger.debug('Setting state to {}'.format(msg.value))
state = msg.value
elif isinstance(msg, singer.SchemaMessage):
table = msg.stream
schemas[table] = msg.schema
key_properties[table] = msg.key_properties
# tables[table] = bigquery.Table(dataset.table(table), schema=build_schema(schemas[table]))
rows[table] = TemporaryFile(mode='w+b')
errors[table] = None
# try:
# tables[table] = bigquery_client.create_table(tables[table])
# except exceptions.Conflict:
# pass
elif isinstance(msg, singer.ActivateVersionMessage):
# This is experimental and won't be used yet
pass
else:
raise Exception("Unrecognized message {}".format(msg))
for table in rows.keys():
table_ref = bigquery_client.dataset(dataset_id).table(table)
SCHEMA = build_schema(schemas[table])
load_config = LoadJobConfig()
load_config.schema = SCHEMA
load_config.source_format = SourceFormat.NEWLINE_DELIMITED_JSON
if truncate:
load_config.write_disposition = WriteDisposition.WRITE_TRUNCATE
rows[table].seek(0)
logger.info("loading {} to Bigquery.\n".format(table))
load_job = bigquery_client.load_table_from_file(
rows[table], table_ref, job_config=load_config)
logger.info("loading job {}".format(load_job.job_id))
logger.info(load_job.result())
# for table in errors.keys():
# if not errors[table]:
# print('Loaded {} row(s) into {}:{}'.format(rows[table], dataset_id, table), tables[table].path)
# else:
# print('Errors:', errors[table], sep=" ")
return state
def persist_lines_job(project_id,
dataset_id,
lines=None,
truncate=False,
validate_records=True):
state = None
schemas = {}
key_properties = {}
rows = {}
errors = {}
bigquery_client = bigquery.Client(project=project_id)
for line in lines:
try:
msg = singer.parse_message(line)
except json.decoder.JSONDecodeError:
logger.error("Unable to parse:\n{}".format(line))
raise
if isinstance(msg, singer.RecordMessage):
if msg.stream not in schemas:
log_message = ('A record for stream {} was encountered '
'before a corresponding schema')
raise Exception(log_message.format(msg.stream))
schema = schemas[msg.stream]
msg.record = convert_dict_keys_to_bigquery_format(
record=msg.record)
if validate_records:
validate(msg.record, schema)
# NEWLINE_DELIMITED_JSON expects literal JSON formatted data,
# with a newline character splitting each row.
dat = bytes(simplejson.dumps(msg.record) + '\n', 'UTF-8')
rows[msg.stream].write(dat)
state = None
elif isinstance(msg, singer.StateMessage):
logger.debug('Setting state to {}'.format(msg.value))
state = msg.value
elif isinstance(msg, singer.SchemaMessage):
table = msg.stream
schema = convert_schema_column_names_to_bigquery_format(
schema=msg.schema)
schemas[table] = schema
key_properties[table] = msg.key_properties
rows[table] = TemporaryFile(mode='w+b')
errors[table] = None
elif isinstance(msg, singer.ActivateVersionMessage):
# This is experimental and won't be used yet
pass
else:
raise Exception("Unrecognized message {}".format(msg))
for table in rows.keys():
table_ref = bigquery_client.dataset(dataset_id).table(table)
SCHEMA = build_schema(schemas[table])
load_config = LoadJobConfig()
load_config.schema = SCHEMA
load_config.source_format = SourceFormat.NEWLINE_DELIMITED_JSON
if truncate:
load_config.write_disposition = WriteDisposition.WRITE_TRUNCATE
rows[table].seek(0)
logger.info("loading {} to Bigquery.\n".format(table))
load_job = bigquery_client.load_table_from_file(rows[table],
table_ref,
job_config=load_config)
logger.info("loading job {}".format(load_job.job_id))
return state
def persist_lines_job(project_id,
dataset_id,
lines=None,
truncate=False,
validate_records=True):
state = None
schemas = {}
rows = {}
bigquery_client = bigquery.Client(project=project_id)
for line in lines:
try:
msg = singer.parse_message(line)
except json.decoder.JSONDecodeError:
logger.error("Unable to parse:\n{}".format(line))
raise
if isinstance(msg, singer.RecordMessage):
if msg.stream not in schemas:
raise Exception(
"A record for stream {} was encountered before a corresponding schema"
.format(msg.stream))
schema = schemas[msg.stream]
if validate_records:
validate(msg.record, schema)
# NEWLINE_DELIMITED_JSON expects JSON string data, with a newline splitting each row.
rows[msg.stream].write(
bytes(json.dumps(msg.record) + "\n", "UTF-8"))
state = None
elif isinstance(msg, singer.StateMessage):
logger.debug("Setting state to {}".format(msg.value))
state = msg.value
elif isinstance(msg, singer.SchemaMessage):
table = msg.stream
schemas[table] = msg.schema
rows[table] = TemporaryFile(mode="w+b")
elif isinstance(msg, singer.ActivateVersionMessage):
# This is experimental and won't be used yet
pass
else:
raise Exception("Unrecognized message {}".format(msg))
for table in rows.keys():
table_ref = bigquery_client.dataset(dataset_id).table(table)
SCHEMA = build_schema(schemas[table])
load_config = LoadJobConfig()
load_config.schema = SCHEMA
load_config.source_format = SourceFormat.NEWLINE_DELIMITED_JSON
if truncate:
load_config.write_disposition = WriteDisposition.WRITE_TRUNCATE
else:
load_config.schema_update_options = [
SchemaUpdateOption.ALLOW_FIELD_ADDITION
]
load_job = bigquery_client.load_table_from_file(rows[table],
table_ref,
job_config=load_config,
rewind=True)
logger.info(
f"Loading '{table}' to BigQuery as job '{load_job.job_id}'",
extra={"stream": table})
try:
load_job.result()
except Exception as e:
logger.error(f"Error on inserting to table '{table}': {str(e)}",
extra={"stream": table})
return
logger.info(f"Loaded {load_job.output_rows} row(s) to '{table}'",
extra={"stream": table})
return state
def add_load_job_csv_config(unhandled_hints: Set[str],
hints: ValidatedRecordsHints,
fail_if_cant_handle_hint: bool,
config: bigquery.LoadJobConfig) -> None:
# source_format: File format of the data.
config.source_format = 'CSV'
# encoding: The character encoding of the data.
# The supported values are UTF-8 or ISO-8859-1.
# "UTF-8 or ISO-8859-1"
#
if hints.encoding == 'UTF8':
config.encoding = 'UTF-8'
else:
# Currently records hints don't support ISO-8859-1
cant_handle_hint(fail_if_cant_handle_hint, 'encoding', hints)
quiet_remove(unhandled_hints, 'encoding')
# field_delimiter: The separator for fields in a CSV file.
assert isinstance(hints.field_delimiter, str)
config.field_delimiter = hints.field_delimiter
quiet_remove(unhandled_hints, 'field-delimiter')
# allow_jagged_rows: Allow missing trailing optional columns (CSV only).
# null_marker: Represents a null value (CSV only)
#
# (documentation is mangled for this one, but I assume the default is
# '' or something sensible, so not messing with it)
# quote_character: Character used to quote data sections (CSV
# only).
#
# [Optional] The value that is used to quote data sections in
# a CSV file. BigQuery converts the string to ISO-8859-1
# encoding, and then uses the first byte of the encoded string
# to split the data in its raw, binary state. The default
# value is a double-quote ('"'). If your data does not contain
# quoted sections, set the property value to an empty
# string. If your data contains quoted newline characters, you
# must also set the allowQuotedNewlines property to
# true.
#
# @default "
# I tried a few combinations and found that when you leave quote_character as the default
#
# * Fields quoted with "" are loaded without the surrounding quotes in the
# string
# * "" becomes " in a quoted field
# * "" stays "" in a non-quoted field
# * nonnumeric quoting works fine
# * full quoting works fine
if hints.quoting is None:
config.quote_character = ''
elif hints.quoting == 'all' or hints.quoting == 'minimal' or hints.quoting == 'nonnumeric':
# allow_quoted_newlines: Allow quoted data containing newline
# characters (CSV only).
config.allow_quoted_newlines = True
assert isinstance(hints.quotechar, str)
config.quote_character = hints.quotechar
if hints.doublequote:
pass
else:
cant_handle_hint(fail_if_cant_handle_hint, 'doublequote', hints)
else:
_assert_never(hints.quoting)
quiet_remove(unhandled_hints, 'quoting')
quiet_remove(unhandled_hints, 'quotechar')
quiet_remove(unhandled_hints, 'doublequote')
# No mention of escaping in BigQuery documentation, and in
# practice backslashes come through without being interpreted.
if hints.escape is None:
pass
else:
cant_handle_hint(fail_if_cant_handle_hint, 'escape', hints)
quiet_remove(unhandled_hints, 'escape')
# skip_leading_rows: Number of rows to skip when reading data (CSV only).
if hints.header_row:
config.skip_leading_rows = 1
else:
config.skip_leading_rows = 0
quiet_remove(unhandled_hints, 'header-row')
# "When you load CSV or JSON data, values in DATE columns must
# use the dash (-) separator and the date must be in the
# following format: YYYY-MM-DD (year-month-day)."
if hints.dateformat == 'YYYY-MM-DD':
pass
else:
cant_handle_hint(fail_if_cant_handle_hint, 'dateformat', hints)
quiet_remove(unhandled_hints, 'dateformat')
# "When you load JSON or CSV data, values in TIMESTAMP columns
# must use a dash (-) separator for the date portion of the
# timestamp, and the date must be in the following format:
# YYYY-MM-DD (year-month-day). The hh:mm:ss
# (hour-minute-second) portion of the timestamp must use a
# colon (:) separator."
#
#
# To test, log into BigQuery web console and try SQL like this
# (assumption is that the same timestamp parser is used during
# CSV loads)
#
# select TIMESTAMP("2000-01-02 16:34:56.789012US/Eastern") as a;
#
# Tests performed and result displayed on console query:
#
# DATE:
# * 01-02-2019 (rejected):
# * 01/02/19 (rejected):
# * 2019-01-01 (accepted): 2019-01-01
# DATETIME:
# * 2019-01-01 1:00pm (rejected):
# * 2019-01-01 1:00:00pm (rejected)
# * 2019-01-01 1:00PM (rejected):
# * 2019-01-01 13:00 (rejected):
# * 2019-01-01 13:00:00 (accepted): 2019-01-01T13:00:00
# * 2019-01-01 1:00pm US/Eastern (rejected):
# * 2019-01-01 1:00:00pm US/Eastern (rejected):
# * 2019-01-01 13:00:00 US/Eastern (rejected):
# * 2019-01-01 13:00:00 EST (rejected):
# * 1997-12-17 07:37:16-08 (rejected)
# * 2019-01-01T13:00:00 (accepted): 2019-01-01T13:00:00
#
# TIME:
# * 1:00pm (rejected):
# * 1:00:00pm (rejected):
# * 13:00 (rejected):
# * 13:00:00 (accepted): 13:00:00
# * 1:00pm US/Eastern (rejected):
# * 1:00pm EST (rejected):
# * 07:37:16-08 (rejected):
#
# TIMESTAMP ("Required format is YYYY-MM-DD
# HH:MM[:SS[.SSSSSS]]", which is BS, as it doesn't specify the
# timezone format):
#
# * 2019-01-01 1:00pm (rejected):
# * 2019-01-01 1:00:00pm (rejected)
# * 2019-01-01 1:00PM (rejected):
# * 2019-01-01 13:00 (rejected):
# * 2019-01-01 13:00:00 (accepted): 2019-01-01T13:00:00
# * 2019-01-01 1:00pm US/Eastern (rejected):
# * 2019-01-01 1:00:00pm US/Eastern (rejected):
# * 2019-01-01 13:00:00 US/Eastern (rejected):
# * 2019-01-01 13:00:00 EST (rejected):
# * 1997-12-17 07:37:16-08 (accepted): 1997-12-17 15:37:16 UTC
# * 2019-01-01T13:00:00-08 (accepted): 2019-01-01 21:00:00 UTC
# * 2000-01-02 16:34:56.789012+0000 (rejected)
# * 2000-01-02 16:34:56.789012+00:00 (accepted)
# * 2000-01-02 16:34:56.789012EST (rejected)
# * 2000-01-02 16:34:56.789012US/Eastern (rejected)
# * 2000-01-02 16:34:56.789012UTC (accepted): 2000-01-02 16:34:56.789012 UTC
# * 2000-01-02 16:34:56.789012 UTC (accepted: 2000-01-02 16:34:56.789012 UTC
#
# https://cloud.google.com/bigquery/docs/reference/standard-sql/data-types#examples
#
# https://stackoverflow.com/questions/47466296/bigquery-datetime-format-csv-to-bigquery-yyyy-mm-dd-hhmmss-ssssss
#
# BigQuery supports exactly one format of ingesting timestamps
# with timezones (what they call 'TIMESTAMP' they call timestamps
# without timezones 'DATETIME'.
#
# That format they accept is ISO 8601, which sounds all nice and
# standardy. Usable timestamps look like 2000-01-02
# 16:34:56.789012+00:00.
# Cool cool. The only issue is that Python's strftime doesn't
# actually provide a way to add the ':' in the timezone
# offset. The only timezone offset code, %z, does not provide the
# colon. Other implementations (GNU libc) offers the %:z option,
# but that doesn't exist in Python and thus in Pandas.
#
# So if you're using Python to export timestamps with timezones,
# you should probably use the `YYYY-MM-DD HH24:MI:SS` format and
# express them in UTC.
#
# https://stackoverflow.com/questions/44836581/does-python-time-strftime-process-timezone-options-correctly-for-rfc-3339
# https://stackoverflow.com/questions/28729212/pandas-save-date-in-iso-format
#
if hints.datetimeformat in ['YYYY-MM-DD HH24:MI:SS', 'YYYY-MM-DD HH:MI:SS']:
pass
else:
cant_handle_hint(fail_if_cant_handle_hint, 'datetimeformat', hints)
quiet_remove(unhandled_hints, 'datetimeformat')
if hints.datetimeformattz in ['YYYY-MM-DD HH:MI:SSOF',
'YYYY-MM-DD HH24:MI:SSOF',
'YYYY-MM-DD HH:MI:SS']:
pass
else:
cant_handle_hint(fail_if_cant_handle_hint, 'datetimeformattz', hints)
quiet_remove(unhandled_hints, 'datetimeformattz')
if hints.timeonlyformat in ['HH24:MI:SS', 'HH:MI:SS']:
pass
else:
cant_handle_hint(fail_if_cant_handle_hint, 'timeonlyformat', hints)
quiet_remove(unhandled_hints, 'timeonlyformat')
# No options to change this. Tested with unix newlines, dos
# newlines and mac newlines and all were understood.:
if hints.record_terminator in ['\n', '\r\n', '\r', None]:
pass
else:
cant_handle_hint(fail_if_cant_handle_hint, 'record-terminator', hints)
quiet_remove(unhandled_hints, 'record-terminator')
# No way to flag compression, but tested uncompressed, with
# gzip and works great. .bz2 gives "400 Unsupported
# compression type". Not sure about .lzo, but pandas can't
# handle it regardless, so doubt it's handled.
if hints.compression is None or hints.compression == 'GZIP':
pass
else:
cant_handle_hint(fail_if_cant_handle_hint, 'compression', hints)
quiet_remove(unhandled_hints, 'compression')
def persist_lines_job(
client,
dataset,
lines=None,
truncate=False,
forced_fulltables=[],
validate_records=True,
table_suffix=None,
):
state = None
schemas = {}
key_properties = {}
rows = {}
errors = {}
table_suffix = table_suffix or ""
for line in lines:
try:
msg = singer.parse_message(line)
except json.decoder.JSONDecodeError:
logger.error("Unable to parse:\n{}".format(line))
raise
if isinstance(msg, singer.RecordMessage):
table_name = msg.stream + table_suffix
if table_name not in schemas:
raise Exception(
"A record for stream {} was encountered before a corresponding schema"
.format(table_name))
schema = schemas[table_name]
if validate_records:
validate(msg.record, schema)
new_rec = filter(schema, msg.record)
# NEWLINE_DELIMITED_JSON expects literal JSON formatted data, with a newline character splitting each row.
data = bytes(
json.dumps(new_rec, cls=DecimalEncoder) + "\n", "UTF-8")
rows[table_name].write(data)
state = None
elif isinstance(msg, singer.StateMessage):
logger.debug("Setting state to {}".format(msg.value))
state = msg.value
elif isinstance(msg, singer.SchemaMessage):
table_name = msg.stream + table_suffix
if table_name in rows:
continue
schemas[table_name] = msg.schema
key_properties[table_name] = msg.key_properties
rows[table_name] = TemporaryFile(mode="w+b")
errors[table_name] = None
elif isinstance(msg, singer.ActivateVersionMessage):
# This is experimental and won't be used yet
pass
else:
raise Exception("Unrecognized message {}".format(msg))
for table in rows.keys():
key_props = key_properties[table]
SCHEMA = build_schema(schemas[table], key_properties=key_props)
load_config = LoadJobConfig()
load_config.schema = SCHEMA
load_config.source_format = SourceFormat.NEWLINE_DELIMITED_JSON
if truncate or (table in forced_fulltables):
logger.info(f"Load {table} by FULL_TABLE")
load_config.write_disposition = WriteDisposition.WRITE_TRUNCATE
logger.info("loading {} to Bigquery.\n".format(table))
try:
load_job = client.load_table_from_file(rows[table],
dataset.table(table),
job_config=load_config,
rewind=True)
logger.info("loading job {}".format(load_job.job_id))
logger.info(load_job.result())
except google_exceptions.BadRequest as err:
logger.error("failed to load table {} from file: {}".format(
table, str(err)))
if load_job.errors:
messages = [
f"reason: {err['reason']}, message: {err['message']}"
for err in load_job.errors
]
logger.error("errors:\n{}".format("\n".join(messages)))
raise
yield state
def persist_lines_job(project_id,
dataset_id,
lines=None,
truncate=False,
validate_records=True):
state = None
schemas = {}
key_properties = {}
tables = {}
rows = {}
errors = {}
bigquery_client = bigquery.Client(project=project_id)
# try:
# dataset = bigquery_client.create_dataset(Dataset(dataset_ref)) or Dataset(dataset_ref)
# except exceptions.Conflict:
# pass
for line in lines:
try:
msg = singer.parse_message(line)
except json.decoder.JSONDecodeError:
logger.error("Unable to parse:\n{}".format(line))
raise
if isinstance(msg, singer.RecordMessage):
if msg.stream not in schemas:
raise Exception(
"A record for stream {} was encountered before a corresponding schema"
.format(msg.stream))
schema = schemas[msg.stream]
if validate_records:
validate(msg.record, schema)
# NEWLINE_DELIMITED_JSON expects literal JSON formatted data, with a newline character splitting each row.
simplified = dict()
for k in msg.record:
v = msg.record[k]
if isinstance(v, decimal.Decimal):
v = float(v)
if isinstance(v, bool):
v = str(v)
simplified[k] = v
json_row = json.dumps(simplified)
rows[msg.stream].write(bytes(json_row, "UTF-8"))
rows[msg.stream].write(bytes("\n", "UTF-8"))
# rows[msg.stream].write(bytes(str(msg.record) + '\n', 'UTF-8'))
state = None
elif isinstance(msg, singer.StateMessage):
logger.debug("Setting state to {}".format(msg.value))
state = msg.value
elif isinstance(msg, singer.SchemaMessage):
table = msg.stream
schemas[table] = json.loads(msg.schema)
key_properties[table] = msg.key_properties
tables[table] = bigquery.Table(
bigquery_client.dataset(dataset_id).table(table),
schema=build_schema(schemas[table]))
rows[table] = TemporaryFile(mode="w+b")
errors[table] = None
try:
tables[table] = bigquery_client.create_table(tables[table])
except exceptions.Conflict:
pass
elif isinstance(msg, singer.ActivateVersionMessage):
# This is experimental and won't be used yet
pass
else:
raise Exception("Unrecognized message {}".format(msg))
for table in rows.keys():
table_ref = bigquery_client.dataset(dataset_id).table(table)
SCHEMA = build_schema(schemas[table])
load_config = LoadJobConfig()
load_config.schema = SCHEMA
load_config.source_format = SourceFormat.NEWLINE_DELIMITED_JSON
if truncate:
load_config.write_disposition = WriteDisposition.WRITE_TRUNCATE
rows[table].seek(0)
logger.info("loading {} to Bigquery.\n".format(table))
data = rows[table]
logger.info(
f"table_ref: {table_ref}, config: {load_config}, data: {data}")
try:
load_job = bigquery_client.load_table_from_file(
data, table_ref, job_config=load_config)
logger.info("loading job {}".format(load_job.job_id))
logger.info(load_job.result())
except exceptions.GoogleAPIError as e:
logger.error(f"Exception in load job: {e}")
for er in e.errors:
logger.error(f"\t Error: {er}")
raise
for table in errors.keys():
if not errors[table]:
print(
"Loaded {} row(s) into {}:{}".format(rows[table], dataset_id,
table),
tables[table].path)
else:
print("Errors: {}", errors[table])
return state