def METHOD_NAME(table: str, args: Namespace) -> Union[bool, str]:
    """Sync one table"""
    mongodb = FastSyncTapMongoDB(args.tap, tap_type_to_target_type)
    snowflake = FastSyncTargetSnowflake(args.target, args.transform)
    tap_id = args.target.get('tap_id')
    archive_load_files = args.target.get('archive_load_files', False)
    try:
        dbname = args.tap.get('dbname')
        filename = utils.gen_export_filename(tap_id=tap_id, table=table)
        filepath = os.path.join(args.temp_dir, filename)
        target_schema = utils.get_target_schema(args.target, table)
        # Open connection
        mongodb.open_connection()
        # Get bookmark - LSN position or Incremental Key value
        bookmark = utils.get_bookmark_for_table(
            table, args.properties, mongodb, dbname=dbname
        )
        # Exporting table data, get table definitions and close connection to avoid timeouts
        mongodb.copy_table(table, filepath, args.temp_dir)
        size_bytes = os.path.getsize(filepath)
        snowflake_types = mongodb.map_column_types_to_target()
        snowflake_columns = snowflake_types.get('columns', [])
        primary_key = snowflake_types['primary_key']
        mongodb.close_connection()
        # Uploading to S3
        s3_key = snowflake.upload_to_s3(filepath, tmp_dir=args.temp_dir)
        # os.remove(filepath)
        # Creating temp table in Snowflake
        snowflake.create_schema(target_schema)
        snowflake.create_table(
            target_schema, table, snowflake_columns, primary_key, is_temporary=True
        )
        # Load into Snowflake table
        snowflake.copy_to_table(
            s3_key,
            target_schema,
            table,
            size_bytes,
            is_temporary=True,
            skip_csv_header=True,
        )
        if archive_load_files:
            # Copy load file to archive
            snowflake.copy_to_archive(s3_key, tap_id, table)
        # Delete file from s3
        snowflake.s3.delete_object(Bucket=args.target.get('s3_bucket'), Key=s3_key)
        # Obfuscate columns
        snowflake.obfuscate_columns(target_schema, table)
        # Create target table and swap with the temp table in Snowflake
        snowflake.create_table(target_schema, table, snowflake_columns, primary_key)
        snowflake.swap_tables(target_schema, table)
        # Save bookmark to singer state file
        # Lock to ensure that only one process writes the same state file at a time
        LOCK.acquire()
        try:
            utils.save_state_file(args.state, table, bookmark)
        finally:
            LOCK.release()
        # Table loaded, grant select on all tables in target schema
        grantees = utils.get_grantees(args.target, table)
        utils.grant_privilege(target_schema, grantees, snowflake.grant_usage_on_schema)
        utils.grant_privilege(target_schema, grantees, snowflake.grant_select_on_schema)
        return True
    except Exception as exc:
        LOGGER.exception(exc)
        return '{}: {}'.format(table, exc)