Example #1
0
    def Run(self, args):
        """This is what gets called when the user runs this command.

    Args:
      args: an argparse namespeace, All the arguments that were provided to this
        command invocation.

    Returns:
      Some value that we want to have printed later.
    """
        apitools_client = self.context[commands.APITOOLS_CLIENT_KEY]
        bigquery_messages = self.context[commands.BIGQUERY_MESSAGES_MODULE_KEY]
        resource_parser = self.context[commands.BIGQUERY_REGISTRY_KEY]
        resource = resource_parser.Parse(args.table_or_view,
                                         collection='bigquery.tables')
        reference = message_conversions.TableResourceToReference(
            bigquery_messages, resource)

        if args.expiration:
            expiration_instant_in_millis = int(
                (bigquery.CurrentTimeInSec() + args.expiration) * 1000)
        else:
            expiration_instant_in_millis = None

        if args.schema:
            new_schema = bigquery_schemas.ReadSchema(args.schema,
                                                     bigquery_messages)
        elif args.schema_file:
            new_schema = bigquery_schemas.ReadSchemaFile(
                args.schema_file, bigquery_messages)
        else:
            new_schema = None

        request = bigquery_messages.BigqueryTablesPatchRequest(
            projectId=reference.projectId,
            datasetId=reference.datasetId,
            tableId=reference.tableId,
            table=bigquery_messages.Table(
                tableReference=reference,
                description=args.description,
                expirationTime=expiration_instant_in_millis,
                friendlyName=args.friendly_name,
                schema=new_schema))

        try:
            apitools_client.tables.Patch(request)
        except apitools_base.HttpError as e:
            raise bigquery.Error.ForHttpError(e)
        log.UpdatedResource(reference)
Example #2
0
    def Run(self, args):
        """This is what gets called when the user runs this command.

    Args:
      args: an argparse namespace, All the arguments that were provided to this
        command invocation.

    Returns:

    """
        apitools_client = self.context[commands.APITOOLS_CLIENT_KEY]
        bigquery_messages = self.context[commands.BIGQUERY_MESSAGES_MODULE_KEY]
        resource_parser = self.context[commands.BIGQUERY_REGISTRY_KEY]
        project_id = properties.VALUES.core.project.Get(required=True)
        table_resource = resource_parser.Parse(args.destination_table,
                                               collection='bigquery.tables')
        # TODO(user): Define constants for collection names in one place
        table_reference = message_conversions.TableResourceToReference(
            bigquery_messages, table_resource)

        sources = _ProcessSources(args.source)

        if args.schema:
            table_schema = bigquery_schemas.ReadSchema(args.schema,
                                                       bigquery_messages)
        elif args.schema_file:
            table_schema = bigquery_schemas.ReadSchemaFile(
                args.schema_file, bigquery_messages)
        else:
            table_schema = None

        normalized_source_format = bigquery_client_helper.NormalizeTextualFormat(
            args.source_format)

        if (not normalized_source_format) or normalized_source_format == 'CSV':
            normalized_quote = (
                args.quote
                and bigquery_client_helper.NormalizeFieldDelimiter(args.quote))
            normalized_skip_leading_rows = args.skip_leading_rows
        else:
            # Server accepts non-None quote and skipLeadingRows only for CSV source
            # format:
            normalized_quote = None
            normalized_skip_leading_rows = None

        load_config = bigquery_messages.JobConfigurationLoad(
            allowJaggedRows=args.allow_jagged_rows,
            allowQuotedNewlines=args.allow_quoted_newlines,
            destinationTable=table_reference,
            encoding=args.encoding and args.encoding.upper(),
            fieldDelimiter=(args.field_delimiter
                            and bigquery_client_helper.NormalizeFieldDelimiter(
                                args.field_delimiter)),
            ignoreUnknownValues=args.ignore_unknown_values,
            maxBadRecords=args.max_bad_records,
            quote=normalized_quote,
            schema=table_schema,
            skipLeadingRows=normalized_skip_leading_rows,
            sourceFormat=normalized_source_format,
            sourceUris=sources if sources[0].startswith('gs://') else [],
            writeDisposition='WRITE_TRUNCATE' if args.replace else None,
        )
        job = job_control.ExecuteJob(
            apitools_client,
            bigquery_messages,
            args,
            configuration=bigquery_messages.JobConfiguration(load=load_config),
            async=args. async,
            project_id=project_id,
            upload_file=None if sources[0].startswith('gs://') else sources[0],
            job_id=job_ids.JobIdProvider().GetJobId(args.job_id,
                                                    args.fingerprint_job_id))
        if args. async:
            job_resource = resource_parser.Create(
                'bigquery.jobs',
                projectId=job.jobReference.projectId,
                jobId=job.jobReference.jobId)
            log.CreatedResource(job_resource)
Example #3
0
    def Run(self, args):
        """This is what gets called when the user runs this command.

    Args:
      args: an argparse namespace, All the arguments that were provided to this
        command invocation.

    Raises:
      bigquery.DuplicateError: if table already exists.
    Returns:
      None
    """
        apitools_client = self.context[commands.APITOOLS_CLIENT_KEY]
        bigquery_messages = self.context[commands.BIGQUERY_MESSAGES_MODULE_KEY]
        resource_parser = self.context[commands.BIGQUERY_REGISTRY_KEY]
        resource = resource_parser.Parse(args.table,
                                         collection='bigquery.tables')
        reference = message_conversions.TableResourceToReference(
            bigquery_messages, resource)

        table_or_view = 'View' if args.view else 'Table'
        if bigquery_client_helper.TableExists(apitools_client,
                                              bigquery_messages, reference):
            if args.if_exists == 'skip':
                log.status.Print(
                    'Skipping this operation because a table or view named '
                    '[{0}] already exists.'.format(reference))
                return
            else:
                message = (
                    '{0} [{1}] could not be created; a table with this name '
                    'already exists.'.format(table_or_view, reference))
                raise bigquery.DuplicateError(message, None, [])
        if args.schema:
            schema = bigquery_schemas.ReadSchema(args.schema,
                                                 bigquery_messages)
        elif args.schema_file:
            schema = bigquery_schemas.ReadSchemaFile(args.schema_file,
                                                     bigquery_messages)
        else:
            schema = None

        if args.expiration:
            expiration_instant_seconds = time.time() + args.expiration
            expiration_instant_millis = int(1000 * expiration_instant_seconds)
        else:
            expiration_instant_millis = None

        if args.view:
            view_definition = bigquery_messages.ViewDefinition(query=args.view)
        else:
            view_definition = None

        request = bigquery_messages.BigqueryTablesInsertRequest(
            projectId=reference.projectId,
            datasetId=reference.datasetId,
            table=bigquery_messages.Table(
                tableReference=bigquery_messages.TableReference(
                    projectId=reference.projectId,
                    datasetId=reference.datasetId,
                    tableId=reference.tableId),
                description=args.description,
                expirationTime=expiration_instant_millis,
                schema=schema,
                view=view_definition))

        try:
            apitools_client.tables.Insert(request)
        except apitools_base.HttpError as server_error:
            raise bigquery.Error.ForHttpError(server_error)

        log.CreatedResource(resource)