No CS Degree Needed Tableau vs Google Looker Studio: What You Need to Know

import time
import os
import csv
from hyperapi import HyperProcess, Telemetry, Connection, CreateMode, TableDefinition, SqlType, Inserter
import requests
from google.oauth2 import service_account
from googleapiclient.discovery import build
import json

# Benchmark configuration
CONFIG = {
    "dataset_rows": 1_000_000,
    "tableau_hyper_path": "./tableau_benchmark.hyper",
    "looker_csv_path": "./looker_benchmark.csv",
    "google_drive_folder_id": "1a2b3c4d5e6f7g8h9i0j",  # Replace with valid Drive folder ID
    "service_account_file": "./service_account.json",  # GCP service account with Drive permissions
    "iterations": 5
}

def generate_test_dataset(row_count: int, output_path: str) -> None:
    \"\"\"Generate a 1M-row CSV with random e-commerce data for testing.\"\"\"
    try:
        with open(output_path, 'w', newline='') as f:
            writer = csv.writer(f)
            writer.writerow(["order_id", "customer_id", "product_id", "order_total", "order_date"])
            for i in range(row_count):
                writer.writerow([i, i % 10000, i % 5000, round(i * 0.12, 2), f"2024-{(i % 12) + 1:02d}-{(i % 28) + 1:02d}"])
        print(f"Generated {row_count} row dataset at {output_path}")
    except IOError as e:
        print(f"Failed to generate dataset: {e}")
        raise

def benchmark_tableau_hyper_load(dataset_path: str, hyper_path: str) -> float:
    \"\"\"Time Tableau Hyper extract creation from CSV, return median time in seconds.\"\"\"
    load_times = []
    for _ in range(CONFIG["iterations"]):
        start = time.perf_counter()
        try:
            # Initialize Hyper process
            with HyperProcess(telemetry=Telemetry.SEND_USAGE_DATA_TO_TABLEAU, parameters={"log_config": ""}) as hyper:
                # Create Hyper connection
                with Connection(endpoint=hyper.endpoint, database=hyper_path, create_mode=CreateMode.CREATE_AND_REPLACE) as connection:
                    # Define table schema matching CSV
                    table_def = TableDefinition(
                        table_name="benchmark_orders",
                        columns=[
                            ("order_id", SqlType.int()),
                            ("customer_id", SqlType.int()),
                            ("product_id", SqlType.int()),
                            ("order_total", SqlType.numeric(10,2)),
                            ("order_date", SqlType.date())
                        ]
                    )
                    connection.catalog.create_table(table_def)
                    # Insert CSV data into Hyper extract
                    with Inserter(connection, table_def) as inserter:
                        with open(dataset_path, 'r') as f:
                            reader = csv.reader(f)
                            next(reader)  # Skip header
                            for row in reader:
                                inserter.add_row([int(row[0]), int(row[1]), int(row[2]), float(row[3]), row[4]])
                        inserter.execute()
            load_times.append(time.perf_counter() - start)
        except Exception as e:
            print(f"Tableau Hyper load failed: {e}")
            raise
        finally:
            if os.path.exists(hyper_path):
                os.remove(hyper_path)
    return sorted(load_times)[CONFIG["iterations"] // 2]  # Median

def benchmark_looker_studio_upload(csv_path: str) -> float:
    \"\"\"Time CSV upload to Google Drive (consumed by Looker Studio), return median time in seconds.\"\"\"
    upload_times = []
    creds = service_account.Credentials.from_service_account_file(
        CONFIG["service_account_file"],
        scopes=["https://www.googleapis.com/auth/drive"]
    )
    service = build("drive", "v3", credentials=creds)
    for _ in range(CONFIG["iterations"]):
        start = time.perf_counter()
        try:
            file_metadata = {
                "name": "looker_benchmark.csv",
                "parents": [CONFIG["google_drive_folder_id"]],
                "mimeType": "text/csv"
            }
            from googleapiclient.http import MediaFileUpload
            media = MediaFileUpload(csv_path, mimetype="text/csv", resumable=True)
            service.files().create(body=file_metadata, media_body=media, fields="id").execute()
            upload_times.append(time.perf_counter() - start)
        except Exception as e:
            print(f"Looker Studio CSV upload failed: {e}")
            raise
    return sorted(upload_times)[CONFIG["iterations"] // 2]

if __name__ == "__main__":
    # Generate test data once
    generate_test_dataset(CONFIG["dataset_rows"], CONFIG["looker_csv_path"])

    # Run benchmarks
    tableau_median = benchmark_tableau_hyper_load(CONFIG["looker_csv_path"], CONFIG["tableau_hyper_path"])
    looker_median = benchmark_looker_studio_upload(CONFIG["looker_csv_path"])

    print(f"\nBenchmark Results (1M rows, {CONFIG['iterations']} iterations):")
    print(f"Tableau 2024.1 Hyper Extract Creation: {tableau_median:.2f}s")
    print(f"Looker Studio 2024.0 CSV Upload: {looker_median:.2f}s")
    print(f"Looker Studio is {((tableau_median - looker_median)/tableau_median)*100:.1f}% faster")

/**
 * Automated Looker Studio Dashboard Deployment Script
 * Deploys a templated dashboard to a target GCP project, configures BigQuery connector,
 * and shares with specified users. Requires Looker Studio API v1 and Drive API v3 scopes.
 */

// Configuration - replace with valid values
const CONFIG = {
  templateDashboardId: "1x2y3z4a5b6c7d8e9f0g",  // Looker Studio template dashboard ID
  targetProjectId: "my-gcp-project-123456",
  bigQueryDataset: "ecommerce.orders",
  shareEmails: ["team@company.com", "bi@company.com"],
  reportName: "Automated Ecommerce Dashboard"
};

/**
 * Main deployment function, triggered via Apps Script trigger or manual run
 */
function deployLookerDashboard() {
  try {
    // Step 1: Copy template dashboard to target project
    const copiedReport = copyTemplateDashboard();
    const reportId = copiedReport.reportId;
    console.log(`Copied template to report ID: ${reportId}`);

    // Step 2: Configure BigQuery data source
    const dataSourceId = configureBigQueryConnector(reportId);
    console.log(`Configured BigQuery connector: ${dataSourceId}`);

    // Step 3: Update report metadata (name, description)
    updateReportMetadata(reportId);

    // Step 4: Share report with target users
    shareReportWithUsers(reportId);
    console.log(`Successfully deployed dashboard: https://lookerstudio.google.com/reporting/${reportId}`);

    return reportId;
  } catch (error) {
    console.error(`Deployment failed: ${error.message}`);
    throw error;
  }
}

/**
 * Copy a Looker Studio template dashboard to the target project
 */
function copyTemplateDashboard() {
  const reportService = LookerStudio.Reports;
  try {
    const copyRequest = {
      name: CONFIG.reportName,
      projectId: CONFIG.targetProjectId
    };
    const response = reportService.copy(CONFIG.templateDashboardId, copyRequest);
    return response;
  } catch (error) {
    throw new Error(`Template copy failed: ${error.message}`);
  }
}

/**
 * Configure BigQuery connector for the report
 */
function configureBigQueryConnector(reportId) {
  const dataSourceService = LookerStudio.DataSources;
  try {
    const dataSourceRequest = {
      reportId: reportId,
      bigQueryConnector: {
        projectId: CONFIG.targetProjectId,
        datasetId: CONFIG.bigQueryDataset.split(".")[0],
        tableId: CONFIG.bigQueryDataset.split(".")[1]
      }
    };
    const dataSource = dataSourceService.create(dataSourceRequest);
    return dataSource.dataSourceId;
  } catch (error) {
    throw new Error(`BigQuery connector config failed: ${error.message}`);
  }
}

/**
 * Update report metadata (name, description)
 */
function updateReportMetadata(reportId) {
  const reportService = LookerStudio.Reports;
  try {
    const updateRequest = {
      reportId: reportId,
      name: CONFIG.reportName,
      description: `Automated dashboard deployed at ${new Date().toISOString()}`
    };
    reportService.patch(updateRequest);
  } catch (error) {
    throw new Error(`Metadata update failed: ${error.message}`);
  }
}

/**
 * Share report with specified users via Drive API
 */
function shareReportWithUsers(reportId) {
  const driveService = Drive.Files;
  try {
    CONFIG.shareEmails.forEach(email => {
      const permissionRequest = {
        type: "user",
        role: "reader",
        emailAddress: email
      };
      driveService.permissions.create(CONFIG.templateDashboardId, permissionRequest);  // Note: Use reportId if using native Looker sharing
    });
  } catch (error) {
    throw new Error(`Sharing failed: ${error.message}`);
  }
}

// Manual run trigger
deployLookerDashboard();

import tableauserverclient as tsc
import github3
import os
import shutil
from pathlib import Path

# Configuration - replace with valid credentials
CONFIG = {
    "tableau_server_url": "https://tableau.company.com",
    "tableau_username": "bi-automation",
    "tableau_password": os.environ.get("TABLEAU_PASSWORD"),
    "tableau_site_id": "default",
    "github_token": os.environ.get("GITHUB_TOKEN"),
    "github_owner": "company",
    "github_repo": "tableau-dashboards",
    "github_branch": "main",
    "local_repo_path": "./tableau-dashboards-repo"
}

def authenticate_tableau() -> tsc.Server:
    \"\"\"Authenticate to Tableau Server and return server object.\"\"\"
    try:
        server = tsc.Server(CONFIG["tableau_server_url"], use_server_version=True)
        server.auth.sign_in(
            tsc.TableauAuth(
                CONFIG["tableau_username"],
                CONFIG["tableau_password"],
                site_id=CONFIG["tableau_site_id"]
            )
        )
        print(f"Authenticated to Tableau Server: {CONFIG['tableau_server_url']}")
        return server
    except Exception as e:
        raise RuntimeError(f"Tableau authentication failed: {e}")

def authenticate_github() -> github3.GitHub:
    \"\"\"Authenticate to GitHub and return GitHub object.\"\"\"
    try:
        gh = github3.login(token=CONFIG["github_token"])
        # Verify authentication
        gh.user().login
        print(f"Authenticated to GitHub as {gh.user().login}")
        return gh
    except Exception as e:
        raise RuntimeError(f"GitHub authentication failed: {e}")

def clone_or_pull_repo(gh: github3.GitHub) -> Path:
    \"\"\"Clone or pull the latest version of the dashboard repo.\"\"\"
    repo_path = Path(CONFIG["local_repo_path"])
    try:
        if repo_path.exists():
            shutil.rmtree(repo_path)
        repo = gh.repository(CONFIG["github_owner"], CONFIG["github_repo"])
        repo.clone(repo_path, branch=CONFIG["github_branch"])
        print(f"Cloned repo to {repo_path}")
        return repo_path
    except Exception as e:
        raise RuntimeError(f"Repo clone failed: {e}")

def download_tableau_workbooks(server: tsc.Server, repo_path: Path) -> None:
    \"\"\"Download all Tableau workbooks to local repo.\"\"\"
    try:
        with server.auth.context():
            all_workbooks = list(tsc.Pager(server.workbooks))
            print(f"Found {len(all_workbooks)} workbooks on server")
            for wb in all_workbooks:
                wb_path = repo_path / f"{wb.name}.twb"
                server.workbooks.download(wb.id, wb_path, include_extract=False)
                print(f"Downloaded workbook: {wb.name} to {wb_path}")
    except Exception as e:
        raise RuntimeError(f"Workbook download failed: {e}")

def commit_and_push_changes(repo_path: Path) -> None:
    \"\"\"Commit local changes and push to GitHub.\"\"\"
    try:
        import subprocess
        # Git commands via subprocess (requires git installed in environment)
        subprocess.run(["git", "add", "."], cwd=repo_path, check=True)
        subprocess.run(
            ["git", "commit", "-m", f"Automated sync: {len(list(repo_path.glob('*.twb')))} workbooks"],
            cwd=repo_path,
            check=True
        )
        subprocess.run(["git", "push", "origin", CONFIG["github_branch"]], cwd=repo_path, check=True)
        print("Pushed changes to GitHub")
    except subprocess.CalledProcessError as e:
        raise RuntimeError(f"Git operation failed: {e.stderr.decode()}")
    except Exception as e:
        raise RuntimeError(f"Commit/push failed: {e}")

if __name__ == "__main__":
    try:
        # Authenticate to services
        tableau_server = authenticate_tableau()
        github_client = authenticate_github()

        # Sync repo
        repo_path = clone_or_pull_repo(github_client)

        # Download workbooks
        download_tableau_workbooks(tableau_server, repo_path)

        # Commit and push
        commit_and_push_changes(repo_path)

        print("Tableau dashboard version control sync completed successfully")
    except Exception as e:
        print(f"Sync failed: {e}")
        raise
    finally:
        if 'tableau_server' in locals():
            tableau_server.auth.sign_out()

import requests

def list_looker_reports(access_token: str) -> list:
    \"\"\"List all Looker Studio reports for the authenticated user.\"\"\"
    headers = {"Authorization": f"Bearer {access_token}"}
    response = requests.get(
        "https://lookerstudio.googleapis.com/v1/reports",
        headers=headers
    )
    response.raise_for_status()
    return response.json().get("reports", [])

import tableauserverclient as tsc
import os

def create_live_postgres_connection(server: tsc.Server, workbook_id: str) -> None:
    \"\"\"Update a Tableau workbook to use a live Postgres connection.\"\"\"
    conn = tsc.ConnectionItem()
    conn.server_address = "postgres.company.com"
    conn.server_port = "5432"
    conn.username = "tableau_user"
    conn.password = os.environ.get("POSTGRES_PASSWORD")
    conn.connection_type = "postgres"
    server.workbooks.update_connection(workbook_id, conn)

// Apps Script to install plugin-git-sync from gallery
function installGitSyncPlugin() {
  const pluginId = "looker-studio-plugin-git-sync-v1";
  const response = UrlFetchApp.fetch(
    `https://lookerstudio.googleapis.com/v1/plugins/${pluginId}/install`,
    {
      method: "POST",
      headers: { "Authorization": `Bearer ${ScriptApp.getOAuthToken()}` }
    }
  );
  Logger.log(`Installed plugin: ${response.getContentText()}`);
}