#!/usr/bin/env bash
set -euo pipefail

BQ_PROJECT=${BQ_PROJECT:?set BQ_PROJECT to your GCP project}
BQ_DATASET=${BQ_DATASET:-food_delivery}
BQ_LOCATION=${BQ_LOCATION:-US}
RELEASE_URI=${RELEASE_URI:?set RELEASE_URI to the gs:// prefix holding your copy of data/}
HERE=$(cd "$(dirname "$0")" && pwd)

bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" show --dataset "$BQ_PROJECT:$BQ_DATASET" >/dev/null 2>&1 || \
  bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" mk --dataset "$BQ_PROJECT:$BQ_DATASET"

# ONLY=A,B loads just those tables. JOBS=N (default 8) loads N tables at a time,
# each by running this script again with ONLY=<table>.
if [[ -z "${ONLY:-}" && "${JOBS:-8}" -gt 1 ]]; then
  printf "%s\n" AP_CHECKS_ALL AP_HOLDS_ALL AP_HOLD_CODES AP_INVOICES_ALL AP_INVOICE_DISTRIBUTIONS_ALL AP_INVOICE_LINES_ALL AP_INVOICE_PAYMENTS_ALL AP_PAYMENT_SCHEDULES_ALL AP_SUPPLIERS AP_SUPPLIER_SITES_ALL AP_TERMS_LINES AP_TERMS_TL AR_ADJUSTMENTS_ALL AR_AGING_BUCKETS AR_AGING_BUCKET_LINES_B AR_AGING_BUCKET_LINES_TL AR_BATCHES_ALL AR_CASH_RECEIPTS_ALL AR_CASH_RECEIPT_HISTORY_ALL AR_DISTRIBUTIONS_ALL AR_PAYMENT_SCHEDULES_ALL AR_RECEIPT_CLASSES AR_RECEIPT_METHODS AR_RECEIVABLES_TRX_ALL AR_RECEIVABLE_APPLICATIONS_ALL CE_BANK_ACCOUNTS CE_BANK_ACCT_USES_ALL CE_GL_ACCOUNTS_CCID CE_STATEMENT_HEADERS CE_STATEMENT_HEADERS_INT CE_STATEMENT_LINES CE_STATEMENT_LINES_INTERFACE CE_STATEMENT_RECONCILS_ALL CE_SYSTEM_PARAMETERS CE_TRANSACTION_CODES FND_APPLICATION FND_APPLICATION_TL FND_CONCURRENT_PROGRAMS FND_CONCURRENT_PROGRAMS_TL FND_CONCURRENT_REQUESTS FND_CURRENCIES FND_CURRENCIES_TL FND_FLEX_HIERARCHIES FND_FLEX_HIERARCHIES_TL FND_FLEX_VALIDATION_QUALIFIERS FND_FLEX_VALUES FND_FLEX_VALUES_TL FND_FLEX_VALUE_HIERARCHIES FND_FLEX_VALUE_NORM_HIERARCHY FND_FLEX_VALUE_SETS FND_ID_FLEXS FND_ID_FLEX_SEGMENTS FND_ID_FLEX_SEGMENTS_TL FND_ID_FLEX_STRUCTURES FND_ID_FLEX_STRUCTURES_TL FND_LANGUAGES FND_LOOKUP_TYPES FND_LOOKUP_TYPES_TL FND_LOOKUP_VALUES FND_RESPONSIBILITY FND_RESPONSIBILITY_TL FND_TERRITORIES FND_TERRITORIES_TL FND_USER GL_ACCOUNT_HIERARCHIES GL_BALANCES GL_CODE_COMBINATIONS GL_IMPORT_REFERENCES GL_INTERFACE GL_JE_BATCHES GL_JE_CATEGORIES_TL GL_JE_HEADERS GL_JE_LINES GL_JE_SOURCES_TL GL_LEDGERS GL_PERIODS GL_PERIOD_STATUSES GL_SUMMARY_TEMPLATES HR_ALL_ORGANIZATION_UNITS HR_LOCATIONS_ALL HR_OPERATING_UNITS HR_ORGANIZATION_INFORMATION HZ_CODE_ASSIGNMENTS HZ_CONTACT_POINTS HZ_CUSTOMER_PROFILES HZ_CUST_ACCOUNTS HZ_CUST_ACCOUNT_ROLES HZ_CUST_ACCT_SITES_ALL HZ_CUST_PROFILE_CLASSES HZ_CUST_SITE_USES_ALL HZ_LOCATIONS HZ_ORGANIZATION_PROFILES HZ_PARTIES HZ_PARTY_SITES IBY_DOCS_PAYABLE_ALL IBY_EXTERNAL_PAYEES_ALL IBY_EXT_BANK_ACCOUNTS IBY_PAYMENTS_ALL IBY_PAY_INSTRUCTIONS_ALL IBY_PMT_INSTR_USES_ALL MTL_CATEGORIES_B MTL_CATEGORIES_TL MTL_CATEGORY_SETS_B MTL_CATEGORY_SETS_TL MTL_ITEM_CATEGORIES MTL_PARAMETERS MTL_SYSTEM_ITEMS_B MTL_SYSTEM_ITEMS_TL MTL_UNITS_OF_MEASURE_TL OE_ORDER_HEADERS_ALL OE_ORDER_LINES_ALL OE_ORDER_SOURCES OE_PRICE_ADJUSTMENTS OE_TRANSACTION_TYPES_ALL OE_TRANSACTION_TYPES_TL OKC_K_HEADERS_ALL_B OKC_K_HEADERS_TL OKC_K_ITEMS OKC_K_LINES_B OKC_K_LINES_TL OKC_K_PARTY_ROLES_B OKC_K_PARTY_ROLES_TL OKC_STATUSES_B OKC_STATUSES_TL OKS_BILL_CONT_LINES OKS_BILL_TXN_LINES OKS_K_LINES_B OKS_K_LINES_TL OKS_LEVEL_ELEMENTS OKS_STREAM_LEVELS_B QP_LIST_HEADERS_B QP_LIST_HEADERS_TL QP_LIST_LINES QP_PRICING_ATTRIBUTES QP_QUALIFIERS RA_BATCH_SOURCES_ALL RA_CUSTOMER_TRX_ALL RA_CUSTOMER_TRX_LINES_ALL RA_CUST_TRX_LINE_GL_DIST_ALL RA_CUST_TRX_TYPES_ALL RA_INTERFACE_LINES_ALL RA_TERMS_B RA_TERMS_LINES RA_TERMS_TL XLA_AE_HEADERS XLA_AE_LINES XLA_DISTRIBUTION_LINKS XLA_EVENTS XLA_EVENT_TYPES_B XLA_EVENT_TYPES_TL XLA_TRANSACTION_ENTITIES XX_AUDIT_TRAIL XX_CAMPAIGN_AUTHORITY_EVENTS XX_CAMPAIGN_BUDGET_CREDITS XX_CARD_FINGERPRINTS XX_CARD_VERIFICATIONS XX_COURIER_ACCOUNT_EVENTS XX_COURIER_APPLICATIONS XX_COURIER_APP_SESSIONS XX_COURIER_DEVICES XX_COURIER_EARNINGS XX_COURIER_IDENTITY_CHECKS XX_COURIER_VIOLATIONS XX_COURIER_WAITS XX_CUSTOMER_ACCOUNT_EVENTS XX_CUSTOMER_DEVICES XX_CUSTOMER_SESSIONS XX_DELIVERY_ASSIGNMENTS XX_DELIVERY_ATTEMPTS XX_DELIVERY_LEGS XX_DEVICES XX_DISPATCH_ASSIGNMENTS XX_DISPUTES XX_DRIVER_LOCATION_OBSERVATIONS XX_DRIVER_PROFILES XX_DRIVER_QUESTS XX_DRIVER_SHIFTS XX_ENFORCEMENT_ACTIONS XX_EXPERIMENT_ASSIGNMENTS XX_FRAUD_WARNINGS XX_GL_INTERFACE_HIST XX_HOTSPOT_SNAPSHOTS XX_INCENTIVE_COMMITMENTS XX_INGESTION_RUNS XX_INTEGRATION_INCIDENTS XX_INTERFACE_ERRORS XX_IP_ADDRESSES XX_LOGIN_ATTEMPTS XX_MARKETPLACE_ESTIMATES XX_MEMBERSHIP_EVENTS XX_MEMBERSHIP_ORDER_BENEFITS XX_MERCHANT_CLOSURES XX_MERCHANT_HANDOFF_CONFIRMATIONS XX_MERCHANT_HOLIDAY_HOURS XX_MERCHANT_HOURS XX_MERCHANT_INTEGRATIONS XX_MERCHANT_OPS_ACTIONS XX_MERCHANT_RATING_SNAPSHOTS XX_MERCHANT_READY_REPORTS XX_MERCHANT_REGULATORY_EVENTS XX_ORDER_PREP_QUOTES XX_ORDER_PROMISES XX_ORDER_REJECTIONS XX_ORDER_STATUS_HIST XX_PAYMENT_AUTHS XX_PAYMENT_INSTRUMENTS XX_PAYOUT_PERIODS XX_PAY_PERIOD_INCENTIVES XX_PREP_ESTIMATE_LOG XX_PROMOTION_ALLOCATIONS XX_PROMOTION_CHECKOUTS XX_PROMOTION_CONTACTS XX_PROMOTION_DECISIONS XX_PROMOTION_SUBMISSIONS XX_PROMOTION_VARIANTS XX_PROMO_ATTEMPTS XX_PROMO_CODES XX_QUEST_INVITATIONS XX_QUEST_PROGRESS XX_QUEST_WINDOWS XX_REFERRALS XX_REFUNDS XX_REVIEWS XX_SUPPLY_FORECASTS XX_SUPPLY_SNAPSHOTS XX_SUPPORT_CASES XX_TIP_ADJUSTMENTS ZX_LINES ZX_LINES_DET_FACTORS ZX_RATES_B ZX_RATES_TL ZX_REGIMES_B ZX_REGIMES_TL ZX_TAXES_B ZX_TAXES_TL |
    xargs -P "${JOBS:-8}" -I{} env ONLY={} JOBS=1 bash "$0"
  exit $?
fi
want() { [[ -z "${ONLY:-}" || ",$ONLY," == *",$1,"* ]]; }

# AP_CHECKS_ALL: 5,239,635 rows
if want AP_CHECKS_ALL; then
echo "AP_CHECKS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_CHECKS_ALL\` (
  \`AMOUNT\` FLOAT64,
  \`BANK_ACCOUNT_ID\` INT64,
  \`BANK_ACCOUNT_NAME\` STRING,
  \`CHECK_DATE\` DATETIME,
  \`CHECK_ID\` INT64,
  \`CHECK_NUMBER\` INT64,
  \`CURRENCY_CODE\` STRING,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`PAYMENT_TYPE_FLAG\` STRING,
  \`CHECKRUN_NAME\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`STATUS_LOOKUP_CODE\` STRING,
  \`CLEARED_DATE\` DATETIME,
  \`ORG_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`VENDOR_SITE_ID\` INT64,
  \`REQUEST_ID\` INT64,
  \`PAYMENT_METHOD_CODE\` STRING,
  \`PAYMENT_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_CHECKS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AP_CHECKS_ALL" "$RELEASE_URI/data/AP_CHECKS_ALL/*.parquet"
fi

# AP_HOLDS_ALL: 31,634 rows
if want AP_HOLDS_ALL; then
echo "AP_HOLDS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_HOLDS_ALL\` (
  \`INVOICE_ID\` INT64,
  \`HOLD_LOOKUP_CODE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`HELD_BY\` INT64,
  \`HOLD_DATE\` DATE,
  \`HOLD_REASON\` STRING,
  \`RELEASE_LOOKUP_CODE\` STRING,
  \`RELEASE_REASON\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`ORG_ID\` INT64,
  \`HOLD_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_HOLDS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AP_HOLDS_ALL" "$RELEASE_URI/data/AP_HOLDS_ALL/*.parquet"
fi

# AP_HOLD_CODES: 13 rows
if want AP_HOLD_CODES; then
echo "AP_HOLD_CODES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_HOLD_CODES\` (
  \`HOLD_LOOKUP_CODE\` STRING,
  \`HOLD_TYPE\` STRING,
  \`DESCRIPTION\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`USER_RELEASEABLE_FLAG\` STRING,
  \`USER_UPDATEABLE_FLAG\` STRING,
  \`POSTABLE_FLAG\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_HOLD_CODES.json" "$BQ_PROJECT:$BQ_DATASET.AP_HOLD_CODES" "$RELEASE_URI/data/AP_HOLD_CODES/*.parquet"
fi

# AP_INVOICES_ALL: 6,051,283 rows
if want AP_INVOICES_ALL; then
echo "AP_INVOICES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_INVOICES_ALL\` (
  \`INVOICE_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`VENDOR_ID\` INT64,
  \`INVOICE_NUM\` STRING,
  \`SET_OF_BOOKS_ID\` INT64,
  \`INVOICE_CURRENCY_CODE\` STRING,
  \`PAYMENT_CURRENCY_CODE\` STRING,
  \`INVOICE_AMOUNT\` FLOAT64,
  \`VENDOR_SITE_ID\` INT64,
  \`INVOICE_DATE\` DATE,
  \`SOURCE\` STRING,
  \`INVOICE_TYPE_LOOKUP_CODE\` STRING,
  \`PAYMENT_STATUS_FLAG\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`APPROVAL_STATUS\` STRING,
  \`ORG_ID\` INT64,
  \`GL_DATE\` DATE,
  \`PAY_GROUP_LOOKUP_CODE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_INVOICES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AP_INVOICES_ALL" "$RELEASE_URI/data/AP_INVOICES_ALL/*.parquet"
fi

# AP_INVOICE_DISTRIBUTIONS_ALL: 7,881,526 rows
if want AP_INVOICE_DISTRIBUTIONS_ALL; then
echo "AP_INVOICE_DISTRIBUTIONS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_INVOICE_DISTRIBUTIONS_ALL\` (
  \`ACCOUNTING_DATE\` DATE,
  \`DISTRIBUTION_LINE_NUMBER\` INT64,
  \`DIST_CODE_COMBINATION_ID\` INT64,
  \`INVOICE_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LINE_TYPE_LOOKUP_CODE\` STRING,
  \`PERIOD_NAME\` STRING,
  \`SET_OF_BOOKS_ID\` INT64,
  \`AMOUNT\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`ORG_ID\` INT64,
  \`INVOICE_DISTRIBUTION_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_INVOICE_DISTRIBUTIONS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AP_INVOICE_DISTRIBUTIONS_ALL" "$RELEASE_URI/data/AP_INVOICE_DISTRIBUTIONS_ALL/*.parquet"
fi

# AP_INVOICE_LINES_ALL: 17,470,894 rows
if want AP_INVOICE_LINES_ALL; then
echo "AP_INVOICE_LINES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_INVOICE_LINES_ALL\` (
  \`INVOICE_ID\` INT64,
  \`LINE_NUMBER\` INT64,
  \`LINE_TYPE_LOOKUP_CODE\` STRING,
  \`DESCRIPTION\` STRING,
  \`ORG_ID\` INT64,
  \`ACCOUNTING_DATE\` DATE,
  \`SET_OF_BOOKS_ID\` INT64,
  \`AMOUNT\` FLOAT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_INVOICE_LINES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AP_INVOICE_LINES_ALL" "$RELEASE_URI/data/AP_INVOICE_LINES_ALL/*.parquet"
fi

# AP_INVOICE_PAYMENTS_ALL: 5,643,336 rows
if want AP_INVOICE_PAYMENTS_ALL; then
echo "AP_INVOICE_PAYMENTS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_INVOICE_PAYMENTS_ALL\` (
  \`ACCOUNTING_DATE\` DATE,
  \`AMOUNT\` FLOAT64,
  \`CHECK_ID\` INT64,
  \`INVOICE_ID\` INT64,
  \`INVOICE_PAYMENT_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`PAYMENT_NUM\` INT64,
  \`PERIOD_NAME\` STRING,
  \`POSTED_FLAG\` STRING,
  \`SET_OF_BOOKS_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_INVOICE_PAYMENTS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AP_INVOICE_PAYMENTS_ALL" "$RELEASE_URI/data/AP_INVOICE_PAYMENTS_ALL/*.parquet"
fi

# AP_PAYMENT_SCHEDULES_ALL: 6,051,283 rows
if want AP_PAYMENT_SCHEDULES_ALL; then
echo "AP_PAYMENT_SCHEDULES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_PAYMENT_SCHEDULES_ALL\` (
  \`INVOICE_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`PAYMENT_NUM\` INT64,
  \`AMOUNT_REMAINING\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`DUE_DATE\` DATE,
  \`GROSS_AMOUNT\` FLOAT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PAYMENT_METHOD_LOOKUP_CODE\` STRING,
  \`PAYMENT_STATUS_FLAG\` STRING,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_PAYMENT_SCHEDULES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AP_PAYMENT_SCHEDULES_ALL" "$RELEASE_URI/data/AP_PAYMENT_SCHEDULES_ALL/*.parquet"
fi

# AP_SUPPLIERS: 99,018 rows
if want AP_SUPPLIERS; then
echo "AP_SUPPLIERS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_SUPPLIERS\` (
  \`VENDOR_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`VENDOR_NAME\` STRING,
  \`VENDOR_NAME_ALT\` STRING,
  \`SEGMENT1\` STRING,
  \`ENABLED_FLAG\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`VENDOR_TYPE_LOOKUP_CODE\` STRING,
  \`START_DATE_ACTIVE\` DATE,
  \`END_DATE_ACTIVE\` DATE,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`PARTY_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_SUPPLIERS.json" "$BQ_PROJECT:$BQ_DATASET.AP_SUPPLIERS" "$RELEASE_URI/data/AP_SUPPLIERS/*.parquet"
fi

# AP_SUPPLIER_SITES_ALL: 99,018 rows
if want AP_SUPPLIER_SITES_ALL; then
echo "AP_SUPPLIER_SITES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_SUPPLIER_SITES_ALL\` (
  \`VENDOR_SITE_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`VENDOR_ID\` INT64,
  \`VENDOR_SITE_CODE\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`PURCHASING_SITE_FLAG\` STRING,
  \`PAY_SITE_FLAG\` STRING,
  \`PAYMENT_METHOD_LOOKUP_CODE\` STRING,
  \`INVOICE_CURRENCY_CODE\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`ORG_ID\` INT64,
  \`LOCATION_ID\` INT64,
  \`PARTY_SITE_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_SUPPLIER_SITES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AP_SUPPLIER_SITES_ALL" "$RELEASE_URI/data/AP_SUPPLIER_SITES_ALL/*.parquet"
fi

# AP_TERMS_LINES: 3 rows
if want AP_TERMS_LINES; then
echo "AP_TERMS_LINES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_TERMS_LINES\` (
  \`TERM_ID\` INT64,
  \`SEQUENCE_NUM\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DUE_PERCENT\` INT64,
  \`DUE_DAYS\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_TERMS_LINES.json" "$BQ_PROJECT:$BQ_DATASET.AP_TERMS_LINES" "$RELEASE_URI/data/AP_TERMS_LINES/*.parquet"
fi

# AP_TERMS_TL: 3 rows
if want AP_TERMS_TL; then
echo "AP_TERMS_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AP_TERMS_TL\` (
  \`TERM_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`NAME\` STRING,
  \`ENABLED_FLAG\` STRING,
  \`DESCRIPTION\` STRING,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AP_TERMS_TL.json" "$BQ_PROJECT:$BQ_DATASET.AP_TERMS_TL" "$RELEASE_URI/data/AP_TERMS_TL/*.parquet"
fi

# AR_ADJUSTMENTS_ALL: 0 rows
if want AR_ADJUSTMENTS_ALL; then
echo "AR_ADJUSTMENTS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_ADJUSTMENTS_ALL\` (
  \`ADJUSTMENT_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`AMOUNT\` FLOAT64,
  \`APPLY_DATE\` DATE,
  \`GL_DATE\` DATE,
  \`SET_OF_BOOKS_ID\` INT64,
  \`TYPE\` STRING,
  \`ADJUSTMENT_TYPE\` STRING,
  \`STATUS\` STRING,
  \`CUSTOMER_TRX_ID\` INT64,
  \`RECEIVABLES_TRX_ID\` INT64,
  \`CREATED_FROM\` STRING,
  \`REASON_CODE\` STRING,
  \`POSTING_CONTROL_ID\` INT64,
  \`ACCTD_AMOUNT\` FLOAT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`ADJUSTMENT_NUMBER\` STRING,
  \`ORG_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_ADJUSTMENTS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AR_ADJUSTMENTS_ALL" "$RELEASE_URI/data/AR_ADJUSTMENTS_ALL/*.parquet"
fi

# AR_AGING_BUCKETS: 1 rows
if want AR_AGING_BUCKETS; then
echo "AR_AGING_BUCKETS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_AGING_BUCKETS\` (
  \`AGING_BUCKET_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`BUCKET_NAME\` STRING,
  \`STATUS\` STRING,
  \`AGING_TYPE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_AGING_BUCKETS.json" "$BQ_PROJECT:$BQ_DATASET.AR_AGING_BUCKETS" "$RELEASE_URI/data/AR_AGING_BUCKETS/*.parquet"
fi

# AR_AGING_BUCKET_LINES_B: 5 rows
if want AR_AGING_BUCKET_LINES_B; then
echo "AR_AGING_BUCKET_LINES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_AGING_BUCKET_LINES_B\` (
  \`AGING_BUCKET_LINE_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`AGING_BUCKET_ID\` INT64,
  \`BUCKET_SEQUENCE_NUM\` INT64,
  \`DAYS_START\` INT64,
  \`DAYS_TO\` INT64,
  \`TYPE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_AGING_BUCKET_LINES_B.json" "$BQ_PROJECT:$BQ_DATASET.AR_AGING_BUCKET_LINES_B" "$RELEASE_URI/data/AR_AGING_BUCKET_LINES_B/*.parquet"
fi

# AR_AGING_BUCKET_LINES_TL: 5 rows
if want AR_AGING_BUCKET_LINES_TL; then
echo "AR_AGING_BUCKET_LINES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_AGING_BUCKET_LINES_TL\` (
  \`AGING_BUCKET_LINE_ID\` INT64,
  \`REPORT_HEADING1\` STRING,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_AGING_BUCKET_LINES_TL.json" "$BQ_PROJECT:$BQ_DATASET.AR_AGING_BUCKET_LINES_TL" "$RELEASE_URI/data/AR_AGING_BUCKET_LINES_TL/*.parquet"
fi

# AR_BATCHES_ALL: 478 rows
if want AR_BATCHES_ALL; then
echo "AR_BATCHES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_BATCHES_ALL\` (
  \`BATCH_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`NAME\` STRING,
  \`BATCH_DATE\` DATETIME,
  \`GL_DATE\` DATETIME,
  \`STATUS\` STRING,
  \`TYPE\` STRING,
  \`BATCH_SOURCE_ID\` INT64,
  \`BATCH_APPLIED_STATUS\` STRING,
  \`CURRENCY_CODE\` STRING,
  \`RECEIPT_METHOD_ID\` INT64,
  \`RECEIPT_CLASS_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`SET_OF_BOOKS_ID\` INT64,
  \`ORG_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_BATCHES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AR_BATCHES_ALL" "$RELEASE_URI/data/AR_BATCHES_ALL/*.parquet"
fi

# AR_CASH_RECEIPTS_ALL: 85,702,095 rows
if want AR_CASH_RECEIPTS_ALL; then
echo "AR_CASH_RECEIPTS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_CASH_RECEIPTS_ALL\` (
  \`CASH_RECEIPT_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`AMOUNT\` FLOAT64,
  \`SET_OF_BOOKS_ID\` INT64,
  \`CURRENCY_CODE\` STRING,
  \`RECEIVABLES_TRX_ID\` INT64,
  \`PAY_FROM_CUSTOMER\` INT64,
  \`STATUS\` STRING,
  \`TYPE\` STRING,
  \`RECEIPT_NUMBER\` STRING,
  \`RECEIPT_DATE\` DATE,
  \`REVERSAL_DATE\` DATE,
  \`REVERSAL_CATEGORY\` STRING,
  \`REVERSAL_COMMENTS\` STRING,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`RECEIPT_METHOD_ID\` INT64,
  \`REQUEST_ID\` INT64,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_CASH_RECEIPTS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AR_CASH_RECEIPTS_ALL" "$RELEASE_URI/data/AR_CASH_RECEIPTS_ALL/*.parquet"
fi

# AR_CASH_RECEIPT_HISTORY_ALL: 257,303,576 rows
if want AR_CASH_RECEIPT_HISTORY_ALL; then
echo "AR_CASH_RECEIPT_HISTORY_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_CASH_RECEIPT_HISTORY_ALL\` (
  \`CASH_RECEIPT_HISTORY_ID\` INT64,
  \`CASH_RECEIPT_ID\` INT64,
  \`STATUS\` STRING,
  \`TRX_DATE\` DATETIME,
  \`AMOUNT\` FLOAT64,
  \`FIRST_POSTED_RECORD_FLAG\` STRING,
  \`POSTABLE_FLAG\` STRING,
  \`FACTOR_FLAG\` STRING,
  \`GL_DATE\` DATETIME,
  \`CURRENT_RECORD_FLAG\` STRING,
  \`BATCH_ID\` INT64,
  \`POSTING_CONTROL_ID\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ACCTD_AMOUNT\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`PRV_STAT_CASH_RECEIPT_HIST_ID\` INT64,
  \`CREATED_FROM\` STRING,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_CASH_RECEIPT_HISTORY_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AR_CASH_RECEIPT_HISTORY_ALL" "$RELEASE_URI/data/AR_CASH_RECEIPT_HISTORY_ALL/*.parquet"
fi

# AR_DISTRIBUTIONS_ALL: 158,503,648 rows
if want AR_DISTRIBUTIONS_ALL; then
echo "AR_DISTRIBUTIONS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_DISTRIBUTIONS_ALL\` (
  \`LINE_ID\` INT64,
  \`SOURCE_ID\` INT64,
  \`SOURCE_TABLE\` STRING,
  \`SOURCE_TYPE\` STRING,
  \`CODE_COMBINATION_ID\` INT64,
  \`AMOUNT_DR\` FLOAT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_DISTRIBUTIONS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AR_DISTRIBUTIONS_ALL" "$RELEASE_URI/data/AR_DISTRIBUTIONS_ALL/*.parquet"
fi

# AR_PAYMENT_SCHEDULES_ALL: 174,181,429 rows
if want AR_PAYMENT_SCHEDULES_ALL; then
echo "AR_PAYMENT_SCHEDULES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_PAYMENT_SCHEDULES_ALL\` (
  \`PAYMENT_SCHEDULE_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DUE_DATE\` DATE,
  \`AMOUNT_DUE_ORIGINAL\` FLOAT64,
  \`AMOUNT_DUE_REMAINING\` FLOAT64,
  \`STATUS\` STRING,
  \`INVOICE_CURRENCY_CODE\` STRING,
  \`CLASS\` STRING,
  \`CUSTOMER_ID\` INT64,
  \`CUSTOMER_TRX_ID\` INT64,
  \`CASH_RECEIPT_ID\` INT64,
  \`GL_DATE_CLOSED\` DATE,
  \`ACTUAL_DATE_CLOSED\` DATE,
  \`AMOUNT_APPLIED\` FLOAT64,
  \`AMOUNT_ADJUSTED\` FLOAT64,
  \`AMOUNT_CREDITED\` FLOAT64,
  \`TRX_NUMBER\` STRING,
  \`TRX_DATE\` DATE,
  \`GL_DATE\` DATE,
  \`ACCTD_AMOUNT_DUE_REMAINING\` FLOAT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_PAYMENT_SCHEDULES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AR_PAYMENT_SCHEDULES_ALL" "$RELEASE_URI/data/AR_PAYMENT_SCHEDULES_ALL/*.parquet"
fi

# AR_RECEIPT_CLASSES: 1 rows
if want AR_RECEIPT_CLASSES; then
echo "AR_RECEIPT_CLASSES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_RECEIPT_CLASSES\` (
  \`RECEIPT_CLASS_ID\` INT64,
  \`CONFIRM_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATION_METHOD_CODE\` STRING,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`CLEAR_FLAG\` STRING,
  \`NAME\` STRING,
  \`REMIT_FLAG\` STRING,
  \`CREATION_STATUS\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_RECEIPT_CLASSES.json" "$BQ_PROJECT:$BQ_DATASET.AR_RECEIPT_CLASSES" "$RELEASE_URI/data/AR_RECEIPT_CLASSES/*.parquet"
fi

# AR_RECEIPT_METHODS: 2 rows
if want AR_RECEIPT_METHODS; then
echo "AR_RECEIPT_METHODS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_RECEIPT_METHODS\` (
  \`RECEIPT_METHOD_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`NAME\` STRING,
  \`RECEIPT_CLASS_ID\` INT64,
  \`START_DATE\` DATE,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_RECEIPT_METHODS.json" "$BQ_PROJECT:$BQ_DATASET.AR_RECEIPT_METHODS" "$RELEASE_URI/data/AR_RECEIPT_METHODS/*.parquet"
fi

# AR_RECEIVABLES_TRX_ALL: 2 rows
if want AR_RECEIVABLES_TRX_ALL; then
echo "AR_RECEIVABLES_TRX_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_RECEIVABLES_TRX_ALL\` (
  \`RECEIVABLES_TRX_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`NAME\` STRING,
  \`SET_OF_BOOKS_ID\` INT64,
  \`DESCRIPTION\` STRING,
  \`STATUS\` STRING,
  \`TYPE\` STRING,
  \`ORG_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_RECEIVABLES_TRX_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AR_RECEIVABLES_TRX_ALL" "$RELEASE_URI/data/AR_RECEIVABLES_TRX_ALL/*.parquet"
fi

# AR_RECEIVABLE_APPLICATIONS_ALL: 90,760,662 rows
if want AR_RECEIVABLE_APPLICATIONS_ALL; then
echo "AR_RECEIVABLE_APPLICATIONS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.AR_RECEIVABLE_APPLICATIONS_ALL\` (
  \`RECEIVABLE_APPLICATION_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`AMOUNT_APPLIED\` FLOAT64,
  \`GL_DATE\` DATE,
  \`CODE_COMBINATION_ID\` INT64,
  \`SET_OF_BOOKS_ID\` INT64,
  \`DISPLAY\` STRING,
  \`APPLY_DATE\` DATE,
  \`APPLICATION_TYPE\` STRING,
  \`STATUS\` STRING,
  \`PAYMENT_SCHEDULE_ID\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CASH_RECEIPT_ID\` INT64,
  \`APPLIED_CUSTOMER_TRX_ID\` INT64,
  \`APPLIED_PAYMENT_SCHEDULE_ID\` INT64,
  \`CUSTOMER_TRX_ID\` INT64,
  \`POSTING_CONTROL_ID\` INT64,
  \`ACCTD_AMOUNT_APPLIED_FROM\` FLOAT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`REVERSAL_GL_DATE\` DATE,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/AR_RECEIVABLE_APPLICATIONS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.AR_RECEIVABLE_APPLICATIONS_ALL" "$RELEASE_URI/data/AR_RECEIVABLE_APPLICATIONS_ALL/*.parquet"
fi

# CE_BANK_ACCOUNTS: 1 rows
if want CE_BANK_ACCOUNTS; then
echo "CE_BANK_ACCOUNTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_BANK_ACCOUNTS\` (
  \`BANK_ACCOUNT_ID\` INT64,
  \`BANK_ACCOUNT_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`BANK_ACCOUNT_NUM\` STRING,
  \`BANK_BRANCH_ID\` INT64,
  \`BANK_ID\` INT64,
  \`CURRENCY_CODE\` STRING,
  \`DESCRIPTION\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`ACCOUNT_OWNER_PARTY_ID\` INT64,
  \`ACCOUNT_OWNER_ORG_ID\` INT64,
  \`ACCOUNT_CLASSIFICATION\` STRING,
  \`AP_USE_ALLOWED_FLAG\` STRING,
  \`AR_USE_ALLOWED_FLAG\` STRING,
  \`XTR_USE_ALLOWED_FLAG\` STRING,
  \`PAY_USE_ALLOWED_FLAG\` STRING,
  \`MULTI_CURRENCY_ALLOWED_FLAG\` STRING,
  \`ZERO_AMOUNT_ALLOWED\` STRING,
  \`BANK_ACCOUNT_TYPE\` STRING,
  \`START_DATE\` DATE,
  \`MASKED_ACCOUNT_NUM\` STRING,
  \`CE_AMOUNT_TOLERANCE\` FLOAT64,
  \`CE_PERCENT_TOLERANCE\` FLOAT64,
  \`ASSET_CODE_COMBINATION_ID\` INT64,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`AUTORECON_AP_MATCHING_ORDER\` STRING,
  \`AUTORECON_AR_MATCHING_ORDER\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_BANK_ACCOUNTS.json" "$BQ_PROJECT:$BQ_DATASET.CE_BANK_ACCOUNTS" "$RELEASE_URI/data/CE_BANK_ACCOUNTS/*.parquet"
fi

# CE_BANK_ACCT_USES_ALL: 1 rows
if want CE_BANK_ACCT_USES_ALL; then
echo "CE_BANK_ACCT_USES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_BANK_ACCT_USES_ALL\` (
  \`BANK_ACCT_USE_ID\` INT64,
  \`BANK_ACCOUNT_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PRIMARY_FLAG\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`ORG_ID\` INT64,
  \`AP_USE_ENABLE_FLAG\` STRING,
  \`AR_USE_ENABLE_FLAG\` STRING,
  \`XTR_USE_ENABLE_FLAG\` STRING,
  \`PAY_USE_ENABLE_FLAG\` STRING,
  \`LEGAL_ENTITY_ID\` INT64,
  \`AUTHORIZED_FLAG\` STRING,
  \`DEFAULT_ACCOUNT_FLAG\` STRING,
  \`OBJECT_VERSION_NUMBER\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_BANK_ACCT_USES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.CE_BANK_ACCT_USES_ALL" "$RELEASE_URI/data/CE_BANK_ACCT_USES_ALL/*.parquet"
fi

# CE_GL_ACCOUNTS_CCID: 1 rows
if want CE_GL_ACCOUNTS_CCID; then
echo "CE_GL_ACCOUNTS_CCID"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_GL_ACCOUNTS_CCID\` (
  \`BANK_ACCT_USE_ID\` INT64,
  \`ASSET_CODE_COMBINATION_ID\` INT64,
  \`AP_ASSET_CCID\` INT64,
  \`AR_ASSET_CCID\` INT64,
  \`CASH_CLEARING_CCID\` INT64,
  \`BANK_CHARGES_CCID\` INT64,
  \`BANK_ERRORS_CCID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`OBJECT_VERSION_NUMBER\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_GL_ACCOUNTS_CCID.json" "$BQ_PROJECT:$BQ_DATASET.CE_GL_ACCOUNTS_CCID" "$RELEASE_URI/data/CE_GL_ACCOUNTS_CCID/*.parquet"
fi

# CE_STATEMENT_HEADERS: 251 rows
if want CE_STATEMENT_HEADERS; then
echo "CE_STATEMENT_HEADERS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_STATEMENT_HEADERS\` (
  \`STATEMENT_HEADER_ID\` INT64,
  \`BANK_ACCOUNT_ID\` INT64,
  \`STATEMENT_NUMBER\` STRING,
  \`STATEMENT_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`AUTO_LOADED_FLAG\` STRING,
  \`GL_DATE\` DATETIME,
  \`CONTROL_BEGIN_BALANCE\` FLOAT64,
  \`CONTROL_TOTAL_DR\` FLOAT64,
  \`CONTROL_TOTAL_CR\` FLOAT64,
  \`CONTROL_END_BALANCE\` FLOAT64,
  \`CONTROL_DR_LINE_COUNT\` INT64,
  \`CONTROL_CR_LINE_COUNT\` INT64,
  \`CURRENCY_CODE\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`STATEMENT_COMPLETE_FLAG\` STRING,
  \`ORG_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_STATEMENT_HEADERS.json" "$BQ_PROJECT:$BQ_DATASET.CE_STATEMENT_HEADERS" "$RELEASE_URI/data/CE_STATEMENT_HEADERS/*.parquet"
fi

# CE_STATEMENT_HEADERS_INT: 0 rows
if want CE_STATEMENT_HEADERS_INT; then
echo "CE_STATEMENT_HEADERS_INT"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_STATEMENT_HEADERS_INT\` (
  \`STATEMENT_NUMBER\` STRING,
  \`BANK_ACCOUNT_NUM\` STRING,
  \`STATEMENT_DATE\` DATETIME,
  \`CONTROL_BEGIN_BALANCE\` FLOAT64,
  \`CONTROL_END_BALANCE\` FLOAT64,
  \`CONTROL_TOTAL_DR\` FLOAT64,
  \`CONTROL_TOTAL_CR\` FLOAT64,
  \`RECORD_STATUS_FLAG\` STRING,
  \`CURRENCY_CODE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_STATEMENT_HEADERS_INT.json" "$BQ_PROJECT:$BQ_DATASET.CE_STATEMENT_HEADERS_INT" "$RELEASE_URI/data/CE_STATEMENT_HEADERS_INT/*.parquet"
fi

# CE_STATEMENT_LINES: 5,395,730 rows
if want CE_STATEMENT_LINES; then
echo "CE_STATEMENT_LINES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_STATEMENT_LINES\` (
  \`STATEMENT_LINE_ID\` INT64,
  \`STATEMENT_HEADER_ID\` INT64,
  \`LINE_NUMBER\` INT64,
  \`TRX_DATE\` DATETIME,
  \`TRX_TYPE\` STRING,
  \`AMOUNT\` FLOAT64,
  \`STATUS\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`TRX_CODE_ID\` INT64,
  \`EFFECTIVE_DATE\` DATETIME,
  \`BANK_TRX_NUMBER\` STRING,
  \`INVOICE_TEXT\` STRING,
  \`CURRENCY_CODE\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CHARGES_AMOUNT\` FLOAT64,
  \`TRX_CODE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_STATEMENT_LINES.json" "$BQ_PROJECT:$BQ_DATASET.CE_STATEMENT_LINES" "$RELEASE_URI/data/CE_STATEMENT_LINES/*.parquet"
fi

# CE_STATEMENT_LINES_INTERFACE: 0 rows
if want CE_STATEMENT_LINES_INTERFACE; then
echo "CE_STATEMENT_LINES_INTERFACE"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_STATEMENT_LINES_INTERFACE\` (
  \`BANK_ACCOUNT_NUM\` STRING,
  \`STATEMENT_NUMBER\` STRING,
  \`LINE_NUMBER\` INT64,
  \`TRX_DATE\` DATETIME,
  \`TRX_CODE\` STRING,
  \`AMOUNT\` FLOAT64,
  \`CURRENCY_CODE\` STRING,
  \`BANK_TRX_NUMBER\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`CHARGES_AMOUNT\` FLOAT64,
  \`BANK_ACCT_CURRENCY_CODE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_STATEMENT_LINES_INTERFACE.json" "$BQ_PROJECT:$BQ_DATASET.CE_STATEMENT_LINES_INTERFACE" "$RELEASE_URI/data/CE_STATEMENT_LINES_INTERFACE/*.parquet"
fi

# CE_STATEMENT_RECONCILS_ALL: 90,593,471 rows
if want CE_STATEMENT_RECONCILS_ALL; then
echo "CE_STATEMENT_RECONCILS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_STATEMENT_RECONCILS_ALL\` (
  \`STATEMENT_LINE_ID\` INT64,
  \`REFERENCE_TYPE\` STRING,
  \`REFERENCE_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`ORG_ID\` INT64,
  \`STATUS_FLAG\` STRING,
  \`CURRENT_RECORD_FLAG\` STRING,
  \`AUTO_RECONCILED_FLAG\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`JE_HEADER_ID\` INT64,
  \`AMOUNT\` FLOAT64,
  \`LEGAL_ENTITY_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_STATEMENT_RECONCILS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.CE_STATEMENT_RECONCILS_ALL" "$RELEASE_URI/data/CE_STATEMENT_RECONCILS_ALL/*.parquet"
fi

# CE_SYSTEM_PARAMETERS: 1 rows
if want CE_SYSTEM_PARAMETERS; then
echo "CE_SYSTEM_PARAMETERS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_SYSTEM_PARAMETERS\` (
  \`SET_OF_BOOKS_ID\` INT64,
  \`CASHBOOK_BEGIN_DATE\` DATE,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`SHOW_CLEARED_FLAG\` STRING,
  \`LINES_PER_COMMIT\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`INTERFACE_PURGE_FLAG\` STRING,
  \`INTERFACE_ARCHIVE_FLAG\` STRING,
  \`LINE_AUTOCREATION_FLAG\` STRING,
  \`SHOW_VOID_PAYMENT_FLAG\` STRING,
  \`MANUAL_AMOUNT_TOLERANCE\` FLOAT64,
  \`MANUAL_PERCENT_TOLERANCE\` FLOAT64,
  \`LEGAL_ENTITY_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_SYSTEM_PARAMETERS.json" "$BQ_PROJECT:$BQ_DATASET.CE_SYSTEM_PARAMETERS" "$RELEASE_URI/data/CE_SYSTEM_PARAMETERS/*.parquet"
fi

# CE_TRANSACTION_CODES: 6 rows
if want CE_TRANSACTION_CODES; then
echo "CE_TRANSACTION_CODES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.CE_TRANSACTION_CODES\` (
  \`TRANSACTION_CODE_ID\` INT64,
  \`BANK_ACCOUNT_ID\` INT64,
  \`TRX_CODE\` STRING,
  \`TRX_TYPE\` STRING,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`DESCRIPTION\` STRING,
  \`RECEIPT_METHOD_ID\` INT64,
  \`CREATE_MISC_TRX_FLAG\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`RECONCILE_FLAG\` STRING,
  \`FLOAT_DAYS\` INT64,
  \`START_DATE\` DATE,
  \`REQUEST_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/CE_TRANSACTION_CODES.json" "$BQ_PROJECT:$BQ_DATASET.CE_TRANSACTION_CODES" "$RELEASE_URI/data/CE_TRANSACTION_CODES/*.parquet"
fi

# FND_APPLICATION: 12 rows
if want FND_APPLICATION; then
echo "FND_APPLICATION"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_APPLICATION\` (
  \`APPLICATION_ID\` INT64,
  \`APPLICATION_SHORT_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`BASEPATH\` STRING,
  \`PRODUCT_CODE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_APPLICATION.json" "$BQ_PROJECT:$BQ_DATASET.FND_APPLICATION" "$RELEASE_URI/data/FND_APPLICATION/*.parquet"
fi

# FND_APPLICATION_TL: 12 rows
if want FND_APPLICATION_TL; then
echo "FND_APPLICATION_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_APPLICATION_TL\` (
  \`APPLICATION_ID\` INT64,
  \`LANGUAGE\` STRING,
  \`APPLICATION_NAME\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_APPLICATION_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_APPLICATION_TL" "$RELEASE_URI/data/FND_APPLICATION_TL/*.parquet"
fi

# FND_CONCURRENT_PROGRAMS: 7 rows
if want FND_CONCURRENT_PROGRAMS; then
echo "FND_CONCURRENT_PROGRAMS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_CONCURRENT_PROGRAMS\` (
  \`APPLICATION_ID\` INT64,
  \`CONCURRENT_PROGRAM_ID\` INT64,
  \`CONCURRENT_PROGRAM_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`EXECUTION_METHOD_CODE\` STRING,
  \`ENABLED_FLAG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_CONCURRENT_PROGRAMS.json" "$BQ_PROJECT:$BQ_DATASET.FND_CONCURRENT_PROGRAMS" "$RELEASE_URI/data/FND_CONCURRENT_PROGRAMS/*.parquet"
fi

# FND_CONCURRENT_PROGRAMS_TL: 7 rows
if want FND_CONCURRENT_PROGRAMS_TL; then
echo "FND_CONCURRENT_PROGRAMS_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_CONCURRENT_PROGRAMS_TL\` (
  \`APPLICATION_ID\` INT64,
  \`CONCURRENT_PROGRAM_ID\` INT64,
  \`LANGUAGE\` STRING,
  \`USER_CONCURRENT_PROGRAM_NAME\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DESCRIPTION\` STRING,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_CONCURRENT_PROGRAMS_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_CONCURRENT_PROGRAMS_TL" "$RELEASE_URI/data/FND_CONCURRENT_PROGRAMS_TL/*.parquet"
fi

# FND_CONCURRENT_REQUESTS: 15,764 rows
if want FND_CONCURRENT_REQUESTS; then
echo "FND_CONCURRENT_REQUESTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_CONCURRENT_REQUESTS\` (
  \`REQUEST_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_DATE\` DATETIME,
  \`REQUESTED_BY\` INT64,
  \`PHASE_CODE\` STRING,
  \`STATUS_CODE\` STRING,
  \`REQUESTED_START_DATE\` DATETIME,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`CONCURRENT_PROGRAM_ID\` INT64,
  \`ACTUAL_START_DATE\` DATETIME,
  \`ACTUAL_COMPLETION_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_CONCURRENT_REQUESTS.json" "$BQ_PROJECT:$BQ_DATASET.FND_CONCURRENT_REQUESTS" "$RELEASE_URI/data/FND_CONCURRENT_REQUESTS/*.parquet"
fi

# FND_CURRENCIES: 68 rows
if want FND_CURRENCIES; then
echo "FND_CURRENCIES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_CURRENCIES\` (
  \`CURRENCY_CODE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ENABLED_FLAG\` STRING,
  \`CURRENCY_FLAG\` STRING,
  \`DESCRIPTION\` STRING,
  \`PRECISION\` INT64,
  \`ISO_FLAG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_CURRENCIES.json" "$BQ_PROJECT:$BQ_DATASET.FND_CURRENCIES" "$RELEASE_URI/data/FND_CURRENCIES/*.parquet"
fi

# FND_CURRENCIES_TL: 68 rows
if want FND_CURRENCIES_TL; then
echo "FND_CURRENCIES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_CURRENCIES_TL\` (
  \`CURRENCY_CODE\` STRING,
  \`LANGUAGE\` STRING,
  \`NAME\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_CURRENCIES_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_CURRENCIES_TL" "$RELEASE_URI/data/FND_CURRENCIES_TL/*.parquet"
fi

# FND_FLEX_HIERARCHIES: 2 rows
if want FND_FLEX_HIERARCHIES; then
echo "FND_FLEX_HIERARCHIES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_FLEX_HIERARCHIES\` (
  \`FLEX_VALUE_SET_ID\` INT64,
  \`HIERARCHY_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`HIERARCHY_CODE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_FLEX_HIERARCHIES.json" "$BQ_PROJECT:$BQ_DATASET.FND_FLEX_HIERARCHIES" "$RELEASE_URI/data/FND_FLEX_HIERARCHIES/*.parquet"
fi

# FND_FLEX_HIERARCHIES_TL: 2 rows
if want FND_FLEX_HIERARCHIES_TL; then
echo "FND_FLEX_HIERARCHIES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_FLEX_HIERARCHIES_TL\` (
  \`FLEX_VALUE_SET_ID\` INT64,
  \`HIERARCHY_ID\` INT64,
  \`HIERARCHY_NAME\` STRING,
  \`LANGUAGE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DESCRIPTION\` STRING,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_FLEX_HIERARCHIES_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_FLEX_HIERARCHIES_TL" "$RELEASE_URI/data/FND_FLEX_HIERARCHIES_TL/*.parquet"
fi

# FND_FLEX_VALIDATION_QUALIFIERS: 5 rows
if want FND_FLEX_VALIDATION_QUALIFIERS; then
echo "FND_FLEX_VALIDATION_QUALIFIERS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_FLEX_VALIDATION_QUALIFIERS\` (
  \`FLEX_VALUE_SET_ID\` INT64,
  \`ID_FLEX_APPLICATION_ID\` INT64,
  \`ID_FLEX_CODE\` STRING,
  \`SEGMENT_ATTRIBUTE_TYPE\` STRING,
  \`VALUE_ATTRIBUTE_TYPE\` STRING,
  \`ASSIGNMENT_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_FLEX_VALIDATION_QUALIFIERS.json" "$BQ_PROJECT:$BQ_DATASET.FND_FLEX_VALIDATION_QUALIFIERS" "$RELEASE_URI/data/FND_FLEX_VALIDATION_QUALIFIERS/*.parquet"
fi

# FND_FLEX_VALUES: 351 rows
if want FND_FLEX_VALUES; then
echo "FND_FLEX_VALUES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_FLEX_VALUES\` (
  \`FLEX_VALUE_SET_ID\` INT64,
  \`FLEX_VALUE_ID\` INT64,
  \`FLEX_VALUE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ENABLED_FLAG\` STRING,
  \`SUMMARY_FLAG\` STRING,
  \`START_DATE_ACTIVE\` DATE,
  \`END_DATE_ACTIVE\` DATE,
  \`PARENT_FLEX_VALUE_LOW\` STRING,
  \`PARENT_FLEX_VALUE_HIGH\` STRING,
  \`STRUCTURED_HIERARCHY_LEVEL\` INT64,
  \`HIERARCHY_LEVEL\` STRING,
  \`COMPILED_VALUE_ATTRIBUTES\` STRING,
  \`VALUE_CATEGORY\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_FLEX_VALUES.json" "$BQ_PROJECT:$BQ_DATASET.FND_FLEX_VALUES" "$RELEASE_URI/data/FND_FLEX_VALUES/*.parquet"
fi

# FND_FLEX_VALUES_TL: 351 rows
if want FND_FLEX_VALUES_TL; then
echo "FND_FLEX_VALUES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_FLEX_VALUES_TL\` (
  \`FLEX_VALUE_ID\` INT64,
  \`LANGUAGE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DESCRIPTION\` STRING,
  \`SOURCE_LANG\` STRING,
  \`FLEX_VALUE_MEANING\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_FLEX_VALUES_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_FLEX_VALUES_TL" "$RELEASE_URI/data/FND_FLEX_VALUES_TL/*.parquet"
fi

# FND_FLEX_VALUE_HIERARCHIES: 33 rows
if want FND_FLEX_VALUE_HIERARCHIES; then
echo "FND_FLEX_VALUE_HIERARCHIES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_FLEX_VALUE_HIERARCHIES\` (
  \`FLEX_VALUE_SET_ID\` INT64,
  \`PARENT_FLEX_VALUE\` STRING,
  \`CHILD_FLEX_VALUE_LOW\` STRING,
  \`CHILD_FLEX_VALUE_HIGH\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`START_DATE_ACTIVE\` DATE,
  \`END_DATE_ACTIVE\` DATE
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_FLEX_VALUE_HIERARCHIES.json" "$BQ_PROJECT:$BQ_DATASET.FND_FLEX_VALUE_HIERARCHIES" "$RELEASE_URI/data/FND_FLEX_VALUE_HIERARCHIES/*.parquet"
fi

# FND_FLEX_VALUE_NORM_HIERARCHY: 26 rows
if want FND_FLEX_VALUE_NORM_HIERARCHY; then
echo "FND_FLEX_VALUE_NORM_HIERARCHY"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_FLEX_VALUE_NORM_HIERARCHY\` (
  \`FLEX_VALUE_SET_ID\` INT64,
  \`PARENT_FLEX_VALUE\` STRING,
  \`RANGE_ATTRIBUTE\` STRING,
  \`CHILD_FLEX_VALUE_LOW\` STRING,
  \`CHILD_FLEX_VALUE_HIGH\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`START_DATE_ACTIVE\` DATE,
  \`END_DATE_ACTIVE\` DATE
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_FLEX_VALUE_NORM_HIERARCHY.json" "$BQ_PROJECT:$BQ_DATASET.FND_FLEX_VALUE_NORM_HIERARCHY" "$RELEASE_URI/data/FND_FLEX_VALUE_NORM_HIERARCHY/*.parquet"
fi

# FND_FLEX_VALUE_SETS: 7 rows
if want FND_FLEX_VALUE_SETS; then
echo "FND_FLEX_VALUE_SETS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_FLEX_VALUE_SETS\` (
  \`FLEX_VALUE_SET_ID\` INT64,
  \`FLEX_VALUE_SET_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`VALIDATION_TYPE\` STRING,
  \`FORMAT_TYPE\` STRING,
  \`MAXIMUM_SIZE\` INT64,
  \`DESCRIPTION\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_FLEX_VALUE_SETS.json" "$BQ_PROJECT:$BQ_DATASET.FND_FLEX_VALUE_SETS" "$RELEASE_URI/data/FND_FLEX_VALUE_SETS/*.parquet"
fi

# FND_ID_FLEXS: 1 rows
if want FND_ID_FLEXS; then
echo "FND_ID_FLEXS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_ID_FLEXS\` (
  \`APPLICATION_ID\` INT64,
  \`ID_FLEX_CODE\` STRING,
  \`ID_FLEX_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`TABLE_APPLICATION_ID\` INT64,
  \`APPLICATION_TABLE_NAME\` STRING,
  \`ALLOW_ID_VALUESETS\` STRING,
  \`DYNAMIC_INSERTS_FEASIBLE_FLAG\` STRING,
  \`INDEX_FLAG\` STRING,
  \`UNIQUE_ID_COLUMN_NAME\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_ID_FLEXS.json" "$BQ_PROJECT:$BQ_DATASET.FND_ID_FLEXS" "$RELEASE_URI/data/FND_ID_FLEXS/*.parquet"
fi

# FND_ID_FLEX_SEGMENTS: 7 rows
if want FND_ID_FLEX_SEGMENTS; then
echo "FND_ID_FLEX_SEGMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_ID_FLEX_SEGMENTS\` (
  \`APPLICATION_ID\` INT64,
  \`ID_FLEX_CODE\` STRING,
  \`ID_FLEX_NUM\` INT64,
  \`APPLICATION_COLUMN_NAME\` STRING,
  \`SEGMENT_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SEGMENT_NUM\` INT64,
  \`APPLICATION_COLUMN_INDEX_FLAG\` STRING,
  \`ENABLED_FLAG\` STRING,
  \`REQUIRED_FLAG\` STRING,
  \`DISPLAY_FLAG\` STRING,
  \`DISPLAY_SIZE\` INT64,
  \`FLEX_VALUE_SET_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_ID_FLEX_SEGMENTS.json" "$BQ_PROJECT:$BQ_DATASET.FND_ID_FLEX_SEGMENTS" "$RELEASE_URI/data/FND_ID_FLEX_SEGMENTS/*.parquet"
fi

# FND_ID_FLEX_SEGMENTS_TL: 7 rows
if want FND_ID_FLEX_SEGMENTS_TL; then
echo "FND_ID_FLEX_SEGMENTS_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_ID_FLEX_SEGMENTS_TL\` (
  \`APPLICATION_ID\` INT64,
  \`ID_FLEX_CODE\` STRING,
  \`ID_FLEX_NUM\` INT64,
  \`APPLICATION_COLUMN_NAME\` STRING,
  \`LANGUAGE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`FORM_LEFT_PROMPT\` STRING,
  \`FORM_ABOVE_PROMPT\` STRING,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_ID_FLEX_SEGMENTS_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_ID_FLEX_SEGMENTS_TL" "$RELEASE_URI/data/FND_ID_FLEX_SEGMENTS_TL/*.parquet"
fi

# FND_ID_FLEX_STRUCTURES: 1 rows
if want FND_ID_FLEX_STRUCTURES; then
echo "FND_ID_FLEX_STRUCTURES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_ID_FLEX_STRUCTURES\` (
  \`APPLICATION_ID\` INT64,
  \`ID_FLEX_CODE\` STRING,
  \`ID_FLEX_NUM\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CONCATENATED_SEGMENT_DELIMITER\` STRING,
  \`CROSS_SEGMENT_VALIDATION_FLAG\` STRING,
  \`DYNAMIC_INSERTS_ALLOWED_FLAG\` STRING,
  \`ENABLED_FLAG\` STRING,
  \`FREEZE_FLEX_DEFINITION_FLAG\` STRING,
  \`ID_FLEX_STRUCTURE_CODE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_ID_FLEX_STRUCTURES.json" "$BQ_PROJECT:$BQ_DATASET.FND_ID_FLEX_STRUCTURES" "$RELEASE_URI/data/FND_ID_FLEX_STRUCTURES/*.parquet"
fi

# FND_ID_FLEX_STRUCTURES_TL: 1 rows
if want FND_ID_FLEX_STRUCTURES_TL; then
echo "FND_ID_FLEX_STRUCTURES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_ID_FLEX_STRUCTURES_TL\` (
  \`APPLICATION_ID\` INT64,
  \`ID_FLEX_CODE\` STRING,
  \`ID_FLEX_NUM\` INT64,
  \`LANGUAGE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ID_FLEX_STRUCTURE_NAME\` STRING,
  \`DESCRIPTION\` STRING,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_ID_FLEX_STRUCTURES_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_ID_FLEX_STRUCTURES_TL" "$RELEASE_URI/data/FND_ID_FLEX_STRUCTURES_TL/*.parquet"
fi

# FND_LANGUAGES: 29 rows
if want FND_LANGUAGES; then
echo "FND_LANGUAGES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_LANGUAGES\` (
  \`LANGUAGE_CODE\` STRING,
  \`LANGUAGE_ID\` INT64,
  \`NLS_LANGUAGE\` STRING,
  \`NLS_TERRITORY\` STRING,
  \`INSTALLED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_LANGUAGES.json" "$BQ_PROJECT:$BQ_DATASET.FND_LANGUAGES" "$RELEASE_URI/data/FND_LANGUAGES/*.parquet"
fi

# FND_LOOKUP_TYPES: 74 rows
if want FND_LOOKUP_TYPES; then
echo "FND_LOOKUP_TYPES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_LOOKUP_TYPES\` (
  \`APPLICATION_ID\` INT64,
  \`LOOKUP_TYPE\` STRING,
  \`CUSTOMIZATION_LEVEL\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SECURITY_GROUP_ID\` INT64,
  \`VIEW_APPLICATION_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_LOOKUP_TYPES.json" "$BQ_PROJECT:$BQ_DATASET.FND_LOOKUP_TYPES" "$RELEASE_URI/data/FND_LOOKUP_TYPES/*.parquet"
fi

# FND_LOOKUP_TYPES_TL: 74 rows
if want FND_LOOKUP_TYPES_TL; then
echo "FND_LOOKUP_TYPES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_LOOKUP_TYPES_TL\` (
  \`LOOKUP_TYPE\` STRING,
  \`SECURITY_GROUP_ID\` INT64,
  \`VIEW_APPLICATION_ID\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`MEANING\` STRING,
  \`DESCRIPTION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_LOOKUP_TYPES_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_LOOKUP_TYPES_TL" "$RELEASE_URI/data/FND_LOOKUP_TYPES_TL/*.parquet"
fi

# FND_LOOKUP_VALUES: 292 rows
if want FND_LOOKUP_VALUES; then
echo "FND_LOOKUP_VALUES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_LOOKUP_VALUES\` (
  \`LOOKUP_TYPE\` STRING,
  \`LANGUAGE\` STRING,
  \`LOOKUP_CODE\` STRING,
  \`MEANING\` STRING,
  \`ENABLED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`SOURCE_LANG\` STRING,
  \`SECURITY_GROUP_ID\` INT64,
  \`VIEW_APPLICATION_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_LOOKUP_VALUES.json" "$BQ_PROJECT:$BQ_DATASET.FND_LOOKUP_VALUES" "$RELEASE_URI/data/FND_LOOKUP_VALUES/*.parquet"
fi

# FND_RESPONSIBILITY: 8 rows
if want FND_RESPONSIBILITY; then
echo "FND_RESPONSIBILITY"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_RESPONSIBILITY\` (
  \`APPLICATION_ID\` INT64,
  \`RESPONSIBILITY_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DATA_GROUP_APPLICATION_ID\` INT64,
  \`DATA_GROUP_ID\` INT64,
  \`MENU_ID\` INT64,
  \`START_DATE\` DATE,
  \`RESPONSIBILITY_KEY\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_RESPONSIBILITY.json" "$BQ_PROJECT:$BQ_DATASET.FND_RESPONSIBILITY" "$RELEASE_URI/data/FND_RESPONSIBILITY/*.parquet"
fi

# FND_RESPONSIBILITY_TL: 8 rows
if want FND_RESPONSIBILITY_TL; then
echo "FND_RESPONSIBILITY_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_RESPONSIBILITY_TL\` (
  \`APPLICATION_ID\` INT64,
  \`RESPONSIBILITY_ID\` INT64,
  \`LANGUAGE\` STRING,
  \`RESPONSIBILITY_NAME\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_RESPONSIBILITY_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_RESPONSIBILITY_TL" "$RELEASE_URI/data/FND_RESPONSIBILITY_TL/*.parquet"
fi

# FND_TERRITORIES: 78 rows
if want FND_TERRITORIES; then
echo "FND_TERRITORIES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_TERRITORIES\` (
  \`TERRITORY_CODE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`OBSOLETE_FLAG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_TERRITORIES.json" "$BQ_PROJECT:$BQ_DATASET.FND_TERRITORIES" "$RELEASE_URI/data/FND_TERRITORIES/*.parquet"
fi

# FND_TERRITORIES_TL: 78 rows
if want FND_TERRITORIES_TL; then
echo "FND_TERRITORIES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_TERRITORIES_TL\` (
  \`TERRITORY_CODE\` STRING,
  \`LANGUAGE\` STRING,
  \`TERRITORY_SHORT_NAME\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_TERRITORIES_TL.json" "$BQ_PROJECT:$BQ_DATASET.FND_TERRITORIES_TL" "$RELEASE_URI/data/FND_TERRITORIES_TL/*.parquet"
fi

# FND_USER: 43 rows
if want FND_USER; then
echo "FND_USER"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.FND_USER\` (
  \`USER_ID\` INT64,
  \`USER_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`START_DATE\` DATE,
  \`END_DATE\` DATE,
  \`DESCRIPTION\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/FND_USER.json" "$BQ_PROJECT:$BQ_DATASET.FND_USER" "$RELEASE_URI/data/FND_USER/*.parquet"
fi

# GL_ACCOUNT_HIERARCHIES: 49,294 rows
if want GL_ACCOUNT_HIERARCHIES; then
echo "GL_ACCOUNT_HIERARCHIES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_ACCOUNT_HIERARCHIES\` (
  \`LEDGER_ID\` INT64,
  \`SUMMARY_CODE_COMBINATION_ID\` INT64,
  \`DETAIL_CODE_COMBINATION_ID\` INT64,
  \`TEMPLATE_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`ORDERING_VALUE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_ACCOUNT_HIERARCHIES.json" "$BQ_PROJECT:$BQ_DATASET.GL_ACCOUNT_HIERARCHIES" "$RELEASE_URI/data/GL_ACCOUNT_HIERARCHIES/*.parquet"
fi

# GL_BALANCES: 204,547 rows
if want GL_BALANCES; then
echo "GL_BALANCES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_BALANCES\` (
  \`LEDGER_ID\` INT64,
  \`CODE_COMBINATION_ID\` INT64,
  \`CURRENCY_CODE\` STRING,
  \`PERIOD_NAME\` STRING,
  \`ACTUAL_FLAG\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`BUDGET_VERSION_ID\` INT64,
  \`ENCUMBRANCE_TYPE_ID\` INT64,
  \`TRANSLATED_FLAG\` STRING,
  \`PERIOD_TYPE\` STRING,
  \`PERIOD_YEAR\` INT64,
  \`PERIOD_NUM\` INT64,
  \`PERIOD_NET_DR\` FLOAT64,
  \`PERIOD_NET_CR\` FLOAT64,
  \`QUARTER_TO_DATE_DR\` FLOAT64,
  \`QUARTER_TO_DATE_CR\` FLOAT64,
  \`PROJECT_TO_DATE_DR\` FLOAT64,
  \`PROJECT_TO_DATE_CR\` FLOAT64,
  \`BEGIN_BALANCE_DR\` FLOAT64,
  \`BEGIN_BALANCE_CR\` FLOAT64,
  \`TEMPLATE_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_BALANCES.json" "$BQ_PROJECT:$BQ_DATASET.GL_BALANCES" "$RELEASE_URI/data/GL_BALANCES/*.parquet"
fi

# GL_CODE_COMBINATIONS: 10,666 rows
if want GL_CODE_COMBINATIONS; then
echo "GL_CODE_COMBINATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_CODE_COMBINATIONS\` (
  \`CODE_COMBINATION_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CHART_OF_ACCOUNTS_ID\` INT64,
  \`DETAIL_POSTING_ALLOWED_FLAG\` STRING,
  \`DETAIL_BUDGETING_ALLOWED_FLAG\` STRING,
  \`ACCOUNT_TYPE\` STRING,
  \`ENABLED_FLAG\` STRING,
  \`SUMMARY_FLAG\` STRING,
  \`SEGMENT1\` STRING,
  \`SEGMENT2\` STRING,
  \`SEGMENT3\` STRING,
  \`SEGMENT4\` STRING,
  \`SEGMENT5\` STRING,
  \`SEGMENT6\` STRING,
  \`SEGMENT7\` STRING,
  \`TEMPLATE_ID\` INT64,
  \`START_DATE_ACTIVE\` DATE,
  \`END_DATE_ACTIVE\` DATE
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_CODE_COMBINATIONS.json" "$BQ_PROJECT:$BQ_DATASET.GL_CODE_COMBINATIONS" "$RELEASE_URI/data/GL_CODE_COMBINATIONS/*.parquet"
fi

# GL_IMPORT_REFERENCES: 904,430,409 rows
if want GL_IMPORT_REFERENCES; then
echo "GL_IMPORT_REFERENCES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_IMPORT_REFERENCES\` (
  \`JE_BATCH_ID\` INT64,
  \`JE_HEADER_ID\` INT64,
  \`JE_LINE_NUM\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REFERENCE_1\` STRING,
  \`REFERENCE_2\` STRING,
  \`REFERENCE_3\` STRING,
  \`REFERENCE_4\` STRING,
  \`REFERENCE_5\` STRING,
  \`REFERENCE_6\` STRING,
  \`REFERENCE_7\` STRING,
  \`GL_SL_LINK_ID\` INT64,
  \`GL_SL_LINK_TABLE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_IMPORT_REFERENCES.json" "$BQ_PROJECT:$BQ_DATASET.GL_IMPORT_REFERENCES" "$RELEASE_URI/data/GL_IMPORT_REFERENCES/*.parquet"
fi

# GL_INTERFACE: 0 rows
if want GL_INTERFACE; then
echo "GL_INTERFACE"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_INTERFACE\` (
  \`STATUS\` STRING,
  \`LEDGER_ID\` INT64,
  \`ACCOUNTING_DATE\` DATETIME,
  \`CURRENCY_CODE\` STRING,
  \`DATE_CREATED\` DATETIME,
  \`CREATED_BY\` INT64,
  \`ACTUAL_FLAG\` STRING,
  \`USER_JE_CATEGORY_NAME\` STRING,
  \`USER_JE_SOURCE_NAME\` STRING,
  \`SEGMENT1\` STRING,
  \`SEGMENT2\` STRING,
  \`SEGMENT3\` STRING,
  \`SEGMENT4\` STRING,
  \`SEGMENT5\` STRING,
  \`ENTERED_DR\` FLOAT64,
  \`ENTERED_CR\` FLOAT64,
  \`REFERENCE1\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_INTERFACE.json" "$BQ_PROJECT:$BQ_DATASET.GL_INTERFACE" "$RELEASE_URI/data/GL_INTERFACE/*.parquet"
fi

# GL_JE_BATCHES: 3,047 rows
if want GL_JE_BATCHES; then
echo "GL_JE_BATCHES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_JE_BATCHES\` (
  \`JE_BATCH_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`NAME\` STRING,
  \`STATUS\` STRING,
  \`ACTUAL_FLAG\` STRING,
  \`DEFAULT_EFFECTIVE_DATE\` DATE,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DEFAULT_PERIOD_NAME\` STRING,
  \`REQUEST_ID\` INT64,
  \`CHART_OF_ACCOUNTS_ID\` INT64,
  \`PERIOD_SET_NAME\` STRING,
  \`ACCOUNTED_PERIOD_TYPE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_JE_BATCHES.json" "$BQ_PROJECT:$BQ_DATASET.GL_JE_BATCHES" "$RELEASE_URI/data/GL_JE_BATCHES/*.parquet"
fi

# GL_JE_CATEGORIES_TL: 9 rows
if want GL_JE_CATEGORIES_TL; then
echo "GL_JE_CATEGORIES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_JE_CATEGORIES_TL\` (
  \`JE_CATEGORY_NAME\` STRING,
  \`USER_JE_CATEGORY_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`JE_CATEGORY_KEY\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_JE_CATEGORIES_TL.json" "$BQ_PROJECT:$BQ_DATASET.GL_JE_CATEGORIES_TL" "$RELEASE_URI/data/GL_JE_CATEGORIES_TL/*.parquet"
fi

# GL_JE_HEADERS: 4,354 rows
if want GL_JE_HEADERS; then
echo "GL_JE_HEADERS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_JE_HEADERS\` (
  \`JE_HEADER_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LEDGER_ID\` INT64,
  \`JE_CATEGORY\` STRING,
  \`JE_SOURCE\` STRING,
  \`PERIOD_NAME\` STRING,
  \`NAME\` STRING,
  \`CURRENCY_CODE\` STRING,
  \`STATUS\` STRING,
  \`ACCRUAL_REV_FLAG\` STRING,
  \`ACTUAL_FLAG\` STRING,
  \`DEFAULT_EFFECTIVE_DATE\` DATE,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`JE_BATCH_ID\` INT64,
  \`ACCRUAL_REV_JE_HEADER_ID\` INT64,
  \`REVERSED_JE_HEADER_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_JE_HEADERS.json" "$BQ_PROJECT:$BQ_DATASET.GL_JE_HEADERS" "$RELEASE_URI/data/GL_JE_HEADERS/*.parquet"
fi

# GL_JE_LINES: 1,821,518 rows
if want GL_JE_LINES; then
echo "GL_JE_LINES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_JE_LINES\` (
  \`JE_HEADER_ID\` INT64,
  \`JE_LINE_NUM\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LEDGER_ID\` INT64,
  \`CODE_COMBINATION_ID\` INT64,
  \`PERIOD_NAME\` STRING,
  \`EFFECTIVE_DATE\` DATE,
  \`STATUS\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ENTERED_DR\` FLOAT64,
  \`ENTERED_CR\` FLOAT64,
  \`ACCOUNTED_DR\` FLOAT64,
  \`ACCOUNTED_CR\` FLOAT64,
  \`DESCRIPTION\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_JE_LINES.json" "$BQ_PROJECT:$BQ_DATASET.GL_JE_LINES" "$RELEASE_URI/data/GL_JE_LINES/*.parquet"
fi

# GL_JE_SOURCES_TL: 9 rows
if want GL_JE_SOURCES_TL; then
echo "GL_JE_SOURCES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_JE_SOURCES_TL\` (
  \`JE_SOURCE_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`OVERRIDE_EDITS_FLAG\` STRING,
  \`USER_JE_SOURCE_NAME\` STRING,
  \`JOURNAL_REFERENCE_FLAG\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`EFFECTIVE_DATE_RULE_CODE\` STRING,
  \`JOURNAL_APPROVAL_FLAG\` STRING,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`IMPORT_USING_KEY_FLAG\` STRING,
  \`JE_SOURCE_KEY\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_JE_SOURCES_TL.json" "$BQ_PROJECT:$BQ_DATASET.GL_JE_SOURCES_TL" "$RELEASE_URI/data/GL_JE_SOURCES_TL/*.parquet"
fi

# GL_LEDGERS: 1 rows
if want GL_LEDGERS; then
echo "GL_LEDGERS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_LEDGERS\` (
  \`LEDGER_ID\` INT64,
  \`NAME\` STRING,
  \`SHORT_NAME\` STRING,
  \`DESCRIPTION\` STRING,
  \`LEDGER_CATEGORY_CODE\` STRING,
  \`ALC_LEDGER_TYPE_CODE\` STRING,
  \`OBJECT_TYPE_CODE\` STRING,
  \`LE_LEDGER_TYPE_CODE\` STRING,
  \`CHART_OF_ACCOUNTS_ID\` INT64,
  \`CURRENCY_CODE\` STRING,
  \`PERIOD_SET_NAME\` STRING,
  \`ACCOUNTED_PERIOD_TYPE\` STRING,
  \`FIRST_LEDGER_PERIOD_NAME\` STRING,
  \`RET_EARN_CODE_COMBINATION_ID\` INT64,
  \`SUSPENSE_ALLOWED_FLAG\` STRING,
  \`ALLOW_INTERCOMPANY_POST_FLAG\` STRING,
  \`TRACK_ROUNDING_IMBALANCE_FLAG\` STRING,
  \`ENABLE_AVERAGE_BALANCES_FLAG\` STRING,
  \`NET_INCOME_CODE_COMBINATION_ID\` INT64,
  \`ENABLE_BUDGETARY_CONTROL_FLAG\` STRING,
  \`REQUIRE_BUDGET_JOURNALS_FLAG\` STRING,
  \`ENABLE_JE_APPROVAL_FLAG\` STRING,
  \`ENABLE_AUTOMATIC_TAX_FLAG\` STRING,
  \`CONSOLIDATION_LEDGER_FLAG\` STRING,
  \`TRANSLATE_EOD_FLAG\` STRING,
  \`TRANSLATE_QATD_FLAG\` STRING,
  \`TRANSLATE_YATD_FLAG\` STRING,
  \`AUTOMATICALLY_CREATED_FLAG\` STRING,
  \`BAL_SEG_VALUE_OPTION_CODE\` STRING,
  \`BAL_SEG_COLUMN_NAME\` STRING,
  \`MGT_SEG_VALUE_OPTION_CODE\` STRING,
  \`BAL_SEG_VALUE_SET_ID\` INT64,
  \`FUTURE_ENTERABLE_PERIODS_LIMIT\` INT64,
  \`LEDGER_ATTRIBUTES\` STRING,
  \`LATEST_OPENED_PERIOD_NAME\` STRING,
  \`SLA_ACCOUNTING_METHOD_CODE\` STRING,
  \`SLA_ACCOUNTING_METHOD_TYPE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ENABLE_RECONCILIATION_FLAG\` STRING,
  \`CREATE_JE_FLAG\` STRING,
  \`NET_CLOSING_BAL_FLAG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_LEDGERS.json" "$BQ_PROJECT:$BQ_DATASET.GL_LEDGERS" "$RELEASE_URI/data/GL_LEDGERS/*.parquet"
fi

# GL_PERIODS: 26 rows
if want GL_PERIODS; then
echo "GL_PERIODS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_PERIODS\` (
  \`PERIOD_SET_NAME\` STRING,
  \`PERIOD_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`START_DATE\` DATE,
  \`END_DATE\` DATE,
  \`PERIOD_TYPE\` STRING,
  \`PERIOD_YEAR\` INT64,
  \`PERIOD_NUM\` INT64,
  \`QUARTER_NUM\` INT64,
  \`ENTERED_PERIOD_NAME\` STRING,
  \`ADJUSTMENT_PERIOD_FLAG\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`YEAR_START_DATE\` DATE,
  \`QUARTER_START_DATE\` DATE
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_PERIODS.json" "$BQ_PROJECT:$BQ_DATASET.GL_PERIODS" "$RELEASE_URI/data/GL_PERIODS/*.parquet"
fi

# GL_PERIOD_STATUSES: 104 rows
if want GL_PERIOD_STATUSES; then
echo "GL_PERIOD_STATUSES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_PERIOD_STATUSES\` (
  \`APPLICATION_ID\` INT64,
  \`SET_OF_BOOKS_ID\` INT64,
  \`PERIOD_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CLOSING_STATUS\` STRING,
  \`START_DATE\` DATE,
  \`END_DATE\` DATE,
  \`PERIOD_TYPE\` STRING,
  \`PERIOD_YEAR\` INT64,
  \`PERIOD_NUM\` INT64,
  \`QUARTER_NUM\` INT64,
  \`ADJUSTMENT_PERIOD_FLAG\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`YEAR_START_DATE\` DATE,
  \`QUARTER_START_DATE\` DATE,
  \`EFFECTIVE_PERIOD_NUM\` INT64,
  \`LEDGER_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_PERIOD_STATUSES.json" "$BQ_PROJECT:$BQ_DATASET.GL_PERIOD_STATUSES" "$RELEASE_URI/data/GL_PERIOD_STATUSES/*.parquet"
fi

# GL_SUMMARY_TEMPLATES: 3 rows
if want GL_SUMMARY_TEMPLATES; then
echo "GL_SUMMARY_TEMPLATES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.GL_SUMMARY_TEMPLATES\` (
  \`TEMPLATE_ID\` INT64,
  \`LEDGER_ID\` INT64,
  \`STATUS\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`TEMPLATE_NAME\` STRING,
  \`CONCATENATED_DESCRIPTION\` STRING,
  \`ACCOUNT_CATEGORY_CODE\` STRING,
  \`MAX_CODE_COMBINATION_ID\` INT64,
  \`START_ACTUALS_PERIOD_NAME\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SEGMENT1_TYPE\` STRING,
  \`SEGMENT2_TYPE\` STRING,
  \`SEGMENT3_TYPE\` STRING,
  \`SEGMENT4_TYPE\` STRING,
  \`SEGMENT5_TYPE\` STRING,
  \`SEGMENT6_TYPE\` STRING,
  \`SEGMENT7_TYPE\` STRING,
  \`DESCRIPTION\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/GL_SUMMARY_TEMPLATES.json" "$BQ_PROJECT:$BQ_DATASET.GL_SUMMARY_TEMPLATES" "$RELEASE_URI/data/GL_SUMMARY_TEMPLATES/*.parquet"
fi

# HR_ALL_ORGANIZATION_UNITS: 17,905 rows
if want HR_ALL_ORGANIZATION_UNITS; then
echo "HR_ALL_ORGANIZATION_UNITS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HR_ALL_ORGANIZATION_UNITS\` (
  \`ORGANIZATION_ID\` INT64,
  \`BUSINESS_GROUP_ID\` INT64,
  \`LOCATION_ID\` INT64,
  \`DATE_FROM\` DATE,
  \`NAME\` STRING,
  \`DATE_TO\` DATE,
  \`TYPE\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HR_ALL_ORGANIZATION_UNITS.json" "$BQ_PROJECT:$BQ_DATASET.HR_ALL_ORGANIZATION_UNITS" "$RELEASE_URI/data/HR_ALL_ORGANIZATION_UNITS/*.parquet"
fi

# HR_LOCATIONS_ALL: 17,902 rows
if want HR_LOCATIONS_ALL; then
echo "HR_LOCATIONS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HR_LOCATIONS_ALL\` (
  \`LOCATION_ID\` INT64,
  \`LOCATION_CODE\` STRING,
  \`ADDRESS_LINE_1\` STRING,
  \`ADDRESS_LINE_2\` STRING,
  \`COUNTRY\` STRING,
  \`DESCRIPTION\` STRING,
  \`INVENTORY_ORGANIZATION_ID\` INT64,
  \`OFFICE_SITE_FLAG\` STRING,
  \`POSTAL_CODE\` STRING,
  \`REGION_2\` STRING,
  \`SHIP_TO_SITE_FLAG\` STRING,
  \`TOWN_OR_CITY\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HR_LOCATIONS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.HR_LOCATIONS_ALL" "$RELEASE_URI/data/HR_LOCATIONS_ALL/*.parquet"
fi

# HR_OPERATING_UNITS: 1 rows
if want HR_OPERATING_UNITS; then
echo "HR_OPERATING_UNITS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HR_OPERATING_UNITS\` (
  \`BUSINESS_GROUP_ID\` INT64,
  \`ORGANIZATION_ID\` INT64,
  \`NAME\` STRING,
  \`DATE_FROM\` DATE,
  \`SHORT_CODE\` STRING,
  \`SET_OF_BOOKS_ID\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HR_OPERATING_UNITS.json" "$BQ_PROJECT:$BQ_DATASET.HR_OPERATING_UNITS" "$RELEASE_URI/data/HR_OPERATING_UNITS/*.parquet"
fi

# HR_ORGANIZATION_INFORMATION: 17,902 rows
if want HR_ORGANIZATION_INFORMATION; then
echo "HR_ORGANIZATION_INFORMATION"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HR_ORGANIZATION_INFORMATION\` (
  \`ORG_INFORMATION_ID\` INT64,
  \`ORG_INFORMATION_CONTEXT\` STRING,
  \`ORGANIZATION_ID\` INT64,
  \`ORG_INFORMATION1\` STRING,
  \`ORG_INFORMATION2\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HR_ORGANIZATION_INFORMATION.json" "$BQ_PROJECT:$BQ_DATASET.HR_ORGANIZATION_INFORMATION" "$RELEASE_URI/data/HR_ORGANIZATION_INFORMATION/*.parquet"
fi

# HZ_CODE_ASSIGNMENTS: 28 rows
if want HZ_CODE_ASSIGNMENTS; then
echo "HZ_CODE_ASSIGNMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_CODE_ASSIGNMENTS\` (
  \`CODE_ASSIGNMENT_ID\` INT64,
  \`OWNER_TABLE_NAME\` STRING,
  \`OWNER_TABLE_ID\` INT64,
  \`CLASS_CATEGORY\` STRING,
  \`CLASS_CODE\` STRING,
  \`PRIMARY_FLAG\` STRING,
  \`START_DATE_ACTIVE\` DATE,
  \`END_DATE_ACTIVE\` DATE,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`STATUS\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_CODE_ASSIGNMENTS.json" "$BQ_PROJECT:$BQ_DATASET.HZ_CODE_ASSIGNMENTS" "$RELEASE_URI/data/HZ_CODE_ASSIGNMENTS/*.parquet"
fi

# HZ_CONTACT_POINTS: 8,452,790 rows
if want HZ_CONTACT_POINTS; then
echo "HZ_CONTACT_POINTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_CONTACT_POINTS\` (
  \`CONTACT_POINT_ID\` INT64,
  \`CONTACT_POINT_TYPE\` STRING,
  \`STATUS\` STRING,
  \`OWNER_TABLE_NAME\` STRING,
  \`OWNER_TABLE_ID\` INT64,
  \`PRIMARY_FLAG\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`EMAIL_ADDRESS\` STRING,
  \`PHONE_NUMBER\` STRING,
  \`PHONE_LINE_TYPE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_CONTACT_POINTS.json" "$BQ_PROJECT:$BQ_DATASET.HZ_CONTACT_POINTS" "$RELEASE_URI/data/HZ_CONTACT_POINTS/*.parquet"
fi

# HZ_CUSTOMER_PROFILES: 4,208,326 rows
if want HZ_CUSTOMER_PROFILES; then
echo "HZ_CUSTOMER_PROFILES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_CUSTOMER_PROFILES\` (
  \`CUST_ACCOUNT_PROFILE_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CUST_ACCOUNT_ID\` INT64,
  \`STATUS\` STRING,
  \`COLLECTOR_ID\` INT64,
  \`CREDIT_CHECKING\` STRING,
  \`TOLERANCE\` INT64,
  \`DISCOUNT_TERMS\` STRING,
  \`DUNNING_LETTERS\` STRING,
  \`INTEREST_CHARGES\` STRING,
  \`SEND_STATEMENTS\` STRING,
  \`CREDIT_BALANCE_STATEMENTS\` STRING,
  \`CREDIT_HOLD\` STRING,
  \`PROFILE_CLASS_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_CUSTOMER_PROFILES.json" "$BQ_PROJECT:$BQ_DATASET.HZ_CUSTOMER_PROFILES" "$RELEASE_URI/data/HZ_CUSTOMER_PROFILES/*.parquet"
fi

# HZ_CUST_ACCOUNTS: 4,208,326 rows
if want HZ_CUST_ACCOUNTS; then
echo "HZ_CUST_ACCOUNTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_CUST_ACCOUNTS\` (
  \`CUST_ACCOUNT_ID\` INT64,
  \`PARTY_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`ACCOUNT_NUMBER\` STRING,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`STATUS\` STRING,
  \`ACCOUNT_ESTABLISHED_DATE\` DATE
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_CUST_ACCOUNTS.json" "$BQ_PROJECT:$BQ_DATASET.HZ_CUST_ACCOUNTS" "$RELEASE_URI/data/HZ_CUST_ACCOUNTS/*.parquet"
fi

# HZ_CUST_ACCOUNT_ROLES: 0 rows
if want HZ_CUST_ACCOUNT_ROLES; then
echo "HZ_CUST_ACCOUNT_ROLES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_CUST_ACCOUNT_ROLES\` (
  \`CUST_ACCOUNT_ROLE_ID\` INT64,
  \`PARTY_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`PRIMARY_FLAG\` STRING,
  \`ROLE_TYPE\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`STATUS\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_CUST_ACCOUNT_ROLES.json" "$BQ_PROJECT:$BQ_DATASET.HZ_CUST_ACCOUNT_ROLES" "$RELEASE_URI/data/HZ_CUST_ACCOUNT_ROLES/*.parquet"
fi

# HZ_CUST_ACCT_SITES_ALL: 18,487,230 rows
if want HZ_CUST_ACCT_SITES_ALL; then
echo "HZ_CUST_ACCT_SITES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_CUST_ACCT_SITES_ALL\` (
  \`CUST_ACCT_SITE_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`PARTY_SITE_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`ORIG_SYSTEM_REFERENCE\` STRING,
  \`STATUS\` STRING,
  \`ORG_ID\` INT64,
  \`BILL_TO_FLAG\` STRING,
  \`SHIP_TO_FLAG\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_CUST_ACCT_SITES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.HZ_CUST_ACCT_SITES_ALL" "$RELEASE_URI/data/HZ_CUST_ACCT_SITES_ALL/*.parquet"
fi

# HZ_CUST_PROFILE_CLASSES: 1 rows
if want HZ_CUST_PROFILE_CLASSES; then
echo "HZ_CUST_PROFILE_CLASSES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_CUST_PROFILE_CLASSES\` (
  \`PROFILE_CLASS_ID\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`NAME\` STRING,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`STATUS\` STRING,
  \`COLLECTOR_ID\` INT64,
  \`CREDIT_CHECKING\` STRING,
  \`TOLERANCE\` INT64,
  \`DISCOUNT_TERMS\` STRING,
  \`DUNNING_LETTERS\` STRING,
  \`INTEREST_CHARGES\` STRING,
  \`STATEMENTS\` STRING,
  \`CREDIT_BALANCE_STATEMENTS\` STRING,
  \`DESCRIPTION\` STRING,
  \`REQUEST_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_CUST_PROFILE_CLASSES.json" "$BQ_PROJECT:$BQ_DATASET.HZ_CUST_PROFILE_CLASSES" "$RELEASE_URI/data/HZ_CUST_PROFILE_CLASSES/*.parquet"
fi

# HZ_CUST_SITE_USES_ALL: 22,695,556 rows
if want HZ_CUST_SITE_USES_ALL; then
echo "HZ_CUST_SITE_USES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_CUST_SITE_USES_ALL\` (
  \`SITE_USE_ID\` INT64,
  \`CUST_ACCT_SITE_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`SITE_USE_CODE\` STRING,
  \`PRIMARY_FLAG\` STRING,
  \`STATUS\` STRING,
  \`LOCATION\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`BILL_TO_SITE_USE_ID\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_CUST_SITE_USES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.HZ_CUST_SITE_USES_ALL" "$RELEASE_URI/data/HZ_CUST_SITE_USES_ALL/*.parquet"
fi

# HZ_LOCATIONS: 16,578,510 rows
if want HZ_LOCATIONS; then
echo "HZ_LOCATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_LOCATIONS\` (
  \`LOCATION_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`COUNTRY\` STRING,
  \`ADDRESS1\` STRING,
  \`ADDRESS2\` STRING,
  \`ADDRESS3\` STRING,
  \`ADDRESS4\` STRING,
  \`CITY\` STRING,
  \`POSTAL_CODE\` STRING,
  \`STATE\` STRING,
  \`ADDRESS_KEY\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_LOCATIONS.json" "$BQ_PROJECT:$BQ_DATASET.HZ_LOCATIONS" "$RELEASE_URI/data/HZ_LOCATIONS/*.parquet"
fi

# HZ_ORGANIZATION_PROFILES: 17,931 rows
if want HZ_ORGANIZATION_PROFILES; then
echo "HZ_ORGANIZATION_PROFILES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_ORGANIZATION_PROFILES\` (
  \`ORGANIZATION_PROFILE_ID\` INT64,
  \`PARTY_ID\` INT64,
  \`ORGANIZATION_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`EFFECTIVE_START_DATE\` DATE,
  \`EFFECTIVE_END_DATE\` DATE,
  \`STATUS\` STRING,
  \`BANK_OR_BRANCH_NUMBER\` STRING,
  \`HOME_COUNTRY\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_ORGANIZATION_PROFILES.json" "$BQ_PROJECT:$BQ_DATASET.HZ_ORGANIZATION_PROFILES" "$RELEASE_URI/data/HZ_ORGANIZATION_PROFILES/*.parquet"
fi

# HZ_PARTIES: 4,307,373 rows
if want HZ_PARTIES; then
echo "HZ_PARTIES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_PARTIES\` (
  \`PARTY_ID\` INT64,
  \`PARTY_NUMBER\` STRING,
  \`PARTY_NAME\` STRING,
  \`PARTY_TYPE\` STRING,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`STATUS\` STRING,
  \`EMAIL_ADDRESS\` STRING,
  \`PRIMARY_PHONE_NUMBER\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_PARTIES.json" "$BQ_PROJECT:$BQ_DATASET.HZ_PARTIES" "$RELEASE_URI/data/HZ_PARTIES/*.parquet"
fi

# HZ_PARTY_SITES: 18,505,132 rows
if want HZ_PARTY_SITES; then
echo "HZ_PARTY_SITES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.HZ_PARTY_SITES\` (
  \`PARTY_SITE_ID\` INT64,
  \`PARTY_ID\` INT64,
  \`LOCATION_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`PARTY_SITE_NUMBER\` STRING,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`IDENTIFYING_ADDRESS_FLAG\` STRING,
  \`STATUS\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/HZ_PARTY_SITES.json" "$BQ_PROJECT:$BQ_DATASET.HZ_PARTY_SITES" "$RELEASE_URI/data/HZ_PARTY_SITES/*.parquet"
fi

# IBY_DOCS_PAYABLE_ALL: 5,643,336 rows
if want IBY_DOCS_PAYABLE_ALL; then
echo "IBY_DOCS_PAYABLE_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.IBY_DOCS_PAYABLE_ALL\` (
  \`PAY_PROC_TRXN_TYPE_CODE\` STRING,
  \`CALLING_APP_ID\` INT64,
  \`CALLING_APP_DOC_REF_NUMBER\` STRING,
  \`DOCUMENT_PAYABLE_ID\` INT64,
  \`PAYMENT_FUNCTION\` STRING,
  \`PAYMENT_DATE\` DATETIME,
  \`DOCUMENT_DATE\` DATETIME,
  \`DOCUMENT_TYPE\` STRING,
  \`DOCUMENT_STATUS\` STRING,
  \`DOCUMENT_AMOUNT\` FLOAT64,
  \`PAYMENT_AMOUNT\` FLOAT64,
  \`PAYMENT_SERVICE_REQUEST_ID\` INT64,
  \`PAYMENT_METHOD_CODE\` STRING,
  \`EXCLUSIVE_PAYMENT_FLAG\` STRING,
  \`STRAIGHT_THROUGH_FLAG\` STRING,
  \`EXT_PAYEE_ID\` INT64,
  \`PAYEE_PARTY_ID\` INT64,
  \`LEGAL_ENTITY_ID\` INT64,
  \`ORG_ID\` INT64,
  \`ALLOW_REMOVING_DOCUMENT_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`CALLING_APP_DOC_UNIQUE_REF1\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ORG_TYPE\` STRING,
  \`PAYMENT_ID\` INT64,
  \`DOCUMENT_CURRENCY_CODE\` STRING,
  \`PAYMENT_CURRENCY_CODE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/IBY_DOCS_PAYABLE_ALL.json" "$BQ_PROJECT:$BQ_DATASET.IBY_DOCS_PAYABLE_ALL" "$RELEASE_URI/data/IBY_DOCS_PAYABLE_ALL/*.parquet"
fi

# IBY_EXTERNAL_PAYEES_ALL: 99,018 rows
if want IBY_EXTERNAL_PAYEES_ALL; then
echo "IBY_EXTERNAL_PAYEES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.IBY_EXTERNAL_PAYEES_ALL\` (
  \`EXT_PAYEE_ID\` INT64,
  \`PAYEE_PARTY_ID\` INT64,
  \`PAYMENT_FUNCTION\` STRING,
  \`EXCLUSIVE_PAYMENT_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SUPPLIER_SITE_ID\` INT64,
  \`ORG_ID\` INT64,
  \`DEFAULT_PAYMENT_METHOD_CODE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/IBY_EXTERNAL_PAYEES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.IBY_EXTERNAL_PAYEES_ALL" "$RELEASE_URI/data/IBY_EXTERNAL_PAYEES_ALL/*.parquet"
fi

# IBY_EXT_BANK_ACCOUNTS: 98,404 rows
if want IBY_EXT_BANK_ACCOUNTS; then
echo "IBY_EXT_BANK_ACCOUNTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.IBY_EXT_BANK_ACCOUNTS\` (
  \`EXT_BANK_ACCOUNT_ID\` INT64,
  \`COUNTRY_CODE\` STRING,
  \`BRANCH_ID\` INT64,
  \`BANK_ID\` INT64,
  \`BANK_ACCOUNT_NUM\` STRING,
  \`CURRENCY_CODE\` STRING,
  \`BANK_ACCOUNT_TYPE\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`START_DATE\` DATE,
  \`END_DATE\` DATE,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/IBY_EXT_BANK_ACCOUNTS.json" "$BQ_PROJECT:$BQ_DATASET.IBY_EXT_BANK_ACCOUNTS" "$RELEASE_URI/data/IBY_EXT_BANK_ACCOUNTS/*.parquet"
fi

# IBY_PAYMENTS_ALL: 5,239,635 rows
if want IBY_PAYMENTS_ALL; then
echo "IBY_PAYMENTS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.IBY_PAYMENTS_ALL\` (
  \`PAYMENT_ID\` INT64,
  \`PAYMENT_METHOD_CODE\` STRING,
  \`PAYMENT_SERVICE_REQUEST_ID\` INT64,
  \`PROCESS_TYPE\` STRING,
  \`PAYMENT_STATUS\` STRING,
  \`PAYMENTS_COMPLETE_FLAG\` STRING,
  \`PAYMENT_FUNCTION\` STRING,
  \`PAYMENT_AMOUNT\` FLOAT64,
  \`BILL_PAYABLE_FLAG\` STRING,
  \`EXCLUSIVE_PAYMENT_FLAG\` STRING,
  \`SEPARATE_REMIT_ADVICE_REQ_FLAG\` STRING,
  \`INTERNAL_BANK_ACCOUNT_ID\` INT64,
  \`ORG_ID\` INT64,
  \`ORG_TYPE\` STRING,
  \`LEGAL_ENTITY_ID\` INT64,
  \`DECLARE_PAYMENT_FLAG\` STRING,
  \`EXT_PAYEE_ID\` INT64,
  \`PAYMENT_INSTRUCTION_ID\` INT64,
  \`PAYMENT_PROFILE_ID\` INT64,
  \`PREGROUPED_PAYMENT_FLAG\` STRING,
  \`STOP_CONFIRMED_FLAG\` STRING,
  \`STOP_RELEASED_FLAG\` STRING,
  \`STOP_REQUEST_PLACED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`PAYEE_PARTY_ID\` INT64,
  \`PAYMENT_DATE\` DATETIME,
  \`PAYMENT_REFERENCE_NUMBER\` INT64,
  \`REQUEST_ID\` INT64,
  \`PAYMENT_CURRENCY_CODE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/IBY_PAYMENTS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.IBY_PAYMENTS_ALL" "$RELEASE_URI/data/IBY_PAYMENTS_ALL/*.parquet"
fi

# IBY_PAY_INSTRUCTIONS_ALL: 1,071 rows
if want IBY_PAY_INSTRUCTIONS_ALL; then
echo "IBY_PAY_INSTRUCTIONS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.IBY_PAY_INSTRUCTIONS_ALL\` (
  \`PAYMENT_INSTRUCTION_ID\` INT64,
  \`PAYMENT_PROFILE_ID\` INT64,
  \`PROCESS_TYPE\` STRING,
  \`PAYMENT_INSTRUCTION_STATUS\` STRING,
  \`PAYMENTS_COMPLETE_CODE\` STRING,
  \`GENERATE_SEP_REMIT_ADVICE_FLAG\` STRING,
  \`REMITTANCE_ADVICE_CREATED_FLAG\` STRING,
  \`REGULATORY_REPORT_CREATED_FLAG\` STRING,
  \`BILL_PAYABLE_FLAG\` STRING,
  \`PAYMENT_COUNT\` INT64,
  \`POSITIVE_PAY_FILE_CREATED_FLAG\` STRING,
  \`PRINT_INSTRUCTION_IMMED_FLAG\` STRING,
  \`TRANSMIT_INSTR_IMMED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`INTERNAL_BANK_ACCOUNT_ID\` INT64,
  \`ORG_ID\` INT64,
  \`PAYMENT_DATE\` DATETIME,
  \`REQUEST_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/IBY_PAY_INSTRUCTIONS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.IBY_PAY_INSTRUCTIONS_ALL" "$RELEASE_URI/data/IBY_PAY_INSTRUCTIONS_ALL/*.parquet"
fi

# IBY_PMT_INSTR_USES_ALL: 100,900 rows
if want IBY_PMT_INSTR_USES_ALL; then
echo "IBY_PMT_INSTR_USES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.IBY_PMT_INSTR_USES_ALL\` (
  \`INSTRUMENT_PAYMENT_USE_ID\` INT64,
  \`PAYMENT_FLOW\` STRING,
  \`EXT_PMT_PARTY_ID\` INT64,
  \`INSTRUMENT_TYPE\` STRING,
  \`INSTRUMENT_ID\` INT64,
  \`PAYMENT_FUNCTION\` STRING,
  \`ORDER_OF_PREFERENCE\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`START_DATE\` DATE,
  \`END_DATE\` DATE
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/IBY_PMT_INSTR_USES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.IBY_PMT_INSTR_USES_ALL" "$RELEASE_URI/data/IBY_PMT_INSTR_USES_ALL/*.parquet"
fi

# MTL_CATEGORIES_B: 70 rows
if want MTL_CATEGORIES_B; then
echo "MTL_CATEGORIES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.MTL_CATEGORIES_B\` (
  \`CATEGORY_ID\` INT64,
  \`STRUCTURE_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SEGMENT1\` STRING,
  \`SUMMARY_FLAG\` STRING,
  \`ENABLED_FLAG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/MTL_CATEGORIES_B.json" "$BQ_PROJECT:$BQ_DATASET.MTL_CATEGORIES_B" "$RELEASE_URI/data/MTL_CATEGORIES_B/*.parquet"
fi

# MTL_CATEGORIES_TL: 70 rows
if want MTL_CATEGORIES_TL; then
echo "MTL_CATEGORIES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.MTL_CATEGORIES_TL\` (
  \`CATEGORY_ID\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`DESCRIPTION\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/MTL_CATEGORIES_TL.json" "$BQ_PROJECT:$BQ_DATASET.MTL_CATEGORIES_TL" "$RELEASE_URI/data/MTL_CATEGORIES_TL/*.parquet"
fi

# MTL_CATEGORY_SETS_B: 1 rows
if want MTL_CATEGORY_SETS_B; then
echo "MTL_CATEGORY_SETS_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.MTL_CATEGORY_SETS_B\` (
  \`CATEGORY_SET_ID\` INT64,
  \`STRUCTURE_ID\` INT64,
  \`VALIDATE_FLAG\` STRING,
  \`CONTROL_LEVEL\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DEFAULT_CATEGORY_ID\` INT64,
  \`MULT_ITEM_CAT_ASSIGN_FLAG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/MTL_CATEGORY_SETS_B.json" "$BQ_PROJECT:$BQ_DATASET.MTL_CATEGORY_SETS_B" "$RELEASE_URI/data/MTL_CATEGORY_SETS_B/*.parquet"
fi

# MTL_CATEGORY_SETS_TL: 1 rows
if want MTL_CATEGORY_SETS_TL; then
echo "MTL_CATEGORY_SETS_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.MTL_CATEGORY_SETS_TL\` (
  \`CATEGORY_SET_ID\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`CATEGORY_SET_NAME\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/MTL_CATEGORY_SETS_TL.json" "$BQ_PROJECT:$BQ_DATASET.MTL_CATEGORY_SETS_TL" "$RELEASE_URI/data/MTL_CATEGORY_SETS_TL/*.parquet"
fi

# MTL_ITEM_CATEGORIES: 1,037,635 rows
if want MTL_ITEM_CATEGORIES; then
echo "MTL_ITEM_CATEGORIES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.MTL_ITEM_CATEGORIES\` (
  \`INVENTORY_ITEM_ID\` INT64,
  \`ORGANIZATION_ID\` INT64,
  \`CATEGORY_SET_ID\` INT64,
  \`CATEGORY_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/MTL_ITEM_CATEGORIES.json" "$BQ_PROJECT:$BQ_DATASET.MTL_ITEM_CATEGORIES" "$RELEASE_URI/data/MTL_ITEM_CATEGORIES/*.parquet"
fi

# MTL_PARAMETERS: 17,903 rows
if want MTL_PARAMETERS; then
echo "MTL_PARAMETERS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.MTL_PARAMETERS\` (
  \`ORGANIZATION_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ORGANIZATION_CODE\` STRING,
  \`MASTER_ORGANIZATION_ID\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/MTL_PARAMETERS.json" "$BQ_PROJECT:$BQ_DATASET.MTL_PARAMETERS" "$RELEASE_URI/data/MTL_PARAMETERS/*.parquet"
fi

# MTL_SYSTEM_ITEMS_B: 1,037,635 rows
if want MTL_SYSTEM_ITEMS_B; then
echo "MTL_SYSTEM_ITEMS_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.MTL_SYSTEM_ITEMS_B\` (
  \`INVENTORY_ITEM_ID\` INT64,
  \`ORGANIZATION_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ENABLED_FLAG\` STRING,
  \`SEGMENT1\` STRING,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`LIST_PRICE_PER_UNIT\` FLOAT64,
  \`PRIMARY_UOM_CODE\` STRING,
  \`INVENTORY_ITEM_STATUS_CODE\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`ITEM_TYPE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/MTL_SYSTEM_ITEMS_B.json" "$BQ_PROJECT:$BQ_DATASET.MTL_SYSTEM_ITEMS_B" "$RELEASE_URI/data/MTL_SYSTEM_ITEMS_B/*.parquet"
fi

# MTL_SYSTEM_ITEMS_TL: 1,037,635 rows
if want MTL_SYSTEM_ITEMS_TL; then
echo "MTL_SYSTEM_ITEMS_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.MTL_SYSTEM_ITEMS_TL\` (
  \`INVENTORY_ITEM_ID\` INT64,
  \`ORGANIZATION_ID\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`DESCRIPTION\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/MTL_SYSTEM_ITEMS_TL.json" "$BQ_PROJECT:$BQ_DATASET.MTL_SYSTEM_ITEMS_TL" "$RELEASE_URI/data/MTL_SYSTEM_ITEMS_TL/*.parquet"
fi

# MTL_UNITS_OF_MEASURE_TL: 1 rows
if want MTL_UNITS_OF_MEASURE_TL; then
echo "MTL_UNITS_OF_MEASURE_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.MTL_UNITS_OF_MEASURE_TL\` (
  \`UNIT_OF_MEASURE\` STRING,
  \`UOM_CODE\` STRING,
  \`UOM_CLASS\` STRING,
  \`BASE_UOM_FLAG\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DESCRIPTION\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`UNIT_OF_MEASURE_TL\` STRING,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/MTL_UNITS_OF_MEASURE_TL.json" "$BQ_PROJECT:$BQ_DATASET.MTL_UNITS_OF_MEASURE_TL" "$RELEASE_URI/data/MTL_UNITS_OF_MEASURE_TL/*.parquet"
fi

# OE_ORDER_HEADERS_ALL: 80,908,384 rows
if want OE_ORDER_HEADERS_ALL; then
echo "OE_ORDER_HEADERS_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OE_ORDER_HEADERS_ALL\` (
  \`HEADER_ID\` INT64,
  \`ORG_ID\` INT64,
  \`ORDER_TYPE_ID\` INT64,
  \`ORDER_NUMBER\` INT64,
  \`ORDER_SOURCE_ID\` INT64,
  \`ORDERED_DATE\` DATETIME,
  \`TRANSACTIONAL_CURR_CODE\` STRING,
  \`SHIPPING_METHOD_CODE\` STRING,
  \`SOLD_TO_ORG_ID\` INT64,
  \`SHIP_FROM_ORG_ID\` INT64,
  \`SHIP_TO_ORG_ID\` INT64,
  \`INVOICE_TO_ORG_ID\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`CANCELLED_FLAG\` STRING,
  \`OPEN_FLAG\` STRING,
  \`BOOKED_FLAG\` STRING,
  \`ORDER_CATEGORY_CODE\` STRING,
  \`FLOW_STATUS_CODE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OE_ORDER_HEADERS_ALL.json" "$BQ_PROJECT:$BQ_DATASET.OE_ORDER_HEADERS_ALL" "$RELEASE_URI/data/OE_ORDER_HEADERS_ALL/*.parquet"
fi

# OE_ORDER_LINES_ALL: 446,720,613 rows
if want OE_ORDER_LINES_ALL; then
echo "OE_ORDER_LINES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OE_ORDER_LINES_ALL\` (
  \`LINE_ID\` INT64,
  \`ORG_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`LINE_TYPE_ID\` INT64,
  \`LINE_NUMBER\` INT64,
  \`ORDERED_QUANTITY\` INT64,
  \`SHIP_FROM_ORG_ID\` INT64,
  \`INVENTORY_ITEM_ID\` INT64,
  \`UNIT_SELLING_PRICE\` FLOAT64,
  \`UNIT_LIST_PRICE\` FLOAT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`ITEM_TYPE_CODE\` STRING,
  \`LINE_CATEGORY_CODE\` STRING,
  \`OPEN_FLAG\` STRING,
  \`BOOKED_FLAG\` STRING,
  \`FLOW_STATUS_CODE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OE_ORDER_LINES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.OE_ORDER_LINES_ALL" "$RELEASE_URI/data/OE_ORDER_LINES_ALL/*.parquet"
fi

# OE_ORDER_SOURCES: 40 rows
if want OE_ORDER_SOURCES; then
echo "OE_ORDER_SOURCES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OE_ORDER_SOURCES\` (
  \`ORDER_SOURCE_ID\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`NAME\` STRING,
  \`DESCRIPTION\` STRING,
  \`ENABLED_FLAG\` STRING,
  \`CREATE_CUSTOMERS_FLAG\` STRING,
  \`USE_IDS_FLAG\` STRING,
  \`AIA_ENABLED_FLAG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OE_ORDER_SOURCES.json" "$BQ_PROJECT:$BQ_DATASET.OE_ORDER_SOURCES" "$RELEASE_URI/data/OE_ORDER_SOURCES/*.parquet"
fi

# OE_PRICE_ADJUSTMENTS: 53,422,133 rows
if want OE_PRICE_ADJUSTMENTS; then
echo "OE_PRICE_ADJUSTMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OE_PRICE_ADJUSTMENTS\` (
  \`PRICE_ADJUSTMENT_ID\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`AUTOMATIC_FLAG\` STRING,
  \`LINE_ID\` INT64,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`LIST_HEADER_ID\` INT64,
  \`LIST_LINE_ID\` INT64,
  \`APPLIED_FLAG\` STRING,
  \`OPERAND\` FLOAT64,
  \`ARITHMETIC_OPERATOR\` STRING,
  \`ADJUSTED_AMOUNT\` FLOAT64,
  \`MODIFIER_LEVEL_CODE\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OE_PRICE_ADJUSTMENTS.json" "$BQ_PROJECT:$BQ_DATASET.OE_PRICE_ADJUSTMENTS" "$RELEASE_URI/data/OE_PRICE_ADJUSTMENTS/*.parquet"
fi

# OE_TRANSACTION_TYPES_ALL: 4 rows
if want OE_TRANSACTION_TYPES_ALL; then
echo "OE_TRANSACTION_TYPES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OE_TRANSACTION_TYPES_ALL\` (
  \`TRANSACTION_TYPE_ID\` INT64,
  \`TRANSACTION_TYPE_CODE\` STRING,
  \`START_DATE_ACTIVE\` DATE,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`REQUEST_ID\` INT64,
  \`CUST_TRX_TYPE_ID\` INT64,
  \`ORG_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OE_TRANSACTION_TYPES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.OE_TRANSACTION_TYPES_ALL" "$RELEASE_URI/data/OE_TRANSACTION_TYPES_ALL/*.parquet"
fi

# OE_TRANSACTION_TYPES_TL: 4 rows
if want OE_TRANSACTION_TYPES_TL; then
echo "OE_TRANSACTION_TYPES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OE_TRANSACTION_TYPES_TL\` (
  \`TRANSACTION_TYPE_ID\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`NAME\` STRING,
  \`DESCRIPTION\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`REQUEST_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OE_TRANSACTION_TYPES_TL.json" "$BQ_PROJECT:$BQ_DATASET.OE_TRANSACTION_TYPES_TL" "$RELEASE_URI/data/OE_TRANSACTION_TYPES_TL/*.parquet"
fi

# OKC_K_HEADERS_ALL_B: 1,611,303 rows
if want OKC_K_HEADERS_ALL_B; then
echo "OKC_K_HEADERS_ALL_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKC_K_HEADERS_ALL_B\` (
  \`ID\` INT64,
  \`CONTRACT_NUMBER\` STRING,
  \`AUTHORING_ORG_ID\` INT64,
  \`INV_ORGANIZATION_ID\` INT64,
  \`STS_CODE\` STRING,
  \`SCS_CODE\` STRING,
  \`CURRENCY_CODE\` STRING,
  \`ARCHIVED_YN\` STRING,
  \`DELETED_YN\` STRING,
  \`TEMPLATE_YN\` STRING,
  \`CHR_TYPE\` STRING,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`TEMPLATE_USED\` STRING,
  \`DATE_APPROVED\` DATE,
  \`DATETIME_CANCELLED\` DATETIME,
  \`AUTO_RENEW_DAYS\` INT64,
  \`DATE_SIGNED\` DATE,
  \`DATE_TERMINATED\` DATE,
  \`START_DATE\` DATE,
  \`END_DATE\` DATE,
  \`BUY_OR_SELL\` STRING,
  \`ISSUE_OR_RECEIVE\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ESTIMATED_AMOUNT\` FLOAT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`PRICE_LIST_ID\` INT64,
  \`GOVERNING_CONTRACT_YN\` STRING,
  \`CUST_ACCT_ID\` INT64,
  \`BILL_TO_SITE_USE_ID\` INT64,
  \`PAYMENT_TERM_ID\` INT64,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKC_K_HEADERS_ALL_B.json" "$BQ_PROJECT:$BQ_DATASET.OKC_K_HEADERS_ALL_B" "$RELEASE_URI/data/OKC_K_HEADERS_ALL_B/*.parquet"
fi

# OKC_K_HEADERS_TL: 1,611,303 rows
if want OKC_K_HEADERS_TL; then
echo "OKC_K_HEADERS_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKC_K_HEADERS_TL\` (
  \`ID\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`SFWT_FLAG\` STRING,
  \`SHORT_DESCRIPTION\` STRING,
  \`COMMENTS\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKC_K_HEADERS_TL.json" "$BQ_PROJECT:$BQ_DATASET.OKC_K_HEADERS_TL" "$RELEASE_URI/data/OKC_K_HEADERS_TL/*.parquet"
fi

# OKC_K_ITEMS: 2,505,907 rows
if want OKC_K_ITEMS; then
echo "OKC_K_ITEMS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKC_K_ITEMS\` (
  \`ID\` INT64,
  \`CLE_ID\` INT64,
  \`CHR_ID\` INT64,
  \`DNZ_CHR_ID\` INT64,
  \`OBJECT1_ID1\` STRING,
  \`OBJECT1_ID2\` STRING,
  \`JTOT_OBJECT1_CODE\` STRING,
  \`UOM_CODE\` STRING,
  \`EXCEPTION_YN\` STRING,
  \`NUMBER_OF_ITEMS\` FLOAT64,
  \`PRICED_ITEM_YN\` STRING,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKC_K_ITEMS.json" "$BQ_PROJECT:$BQ_DATASET.OKC_K_ITEMS" "$RELEASE_URI/data/OKC_K_ITEMS/*.parquet"
fi

# OKC_K_LINES_B: 2,505,907 rows
if want OKC_K_LINES_B; then
echo "OKC_K_LINES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKC_K_LINES_B\` (
  \`ID\` INT64,
  \`LINE_NUMBER\` STRING,
  \`CHR_ID\` INT64,
  \`DNZ_CHR_ID\` INT64,
  \`DISPLAY_SEQUENCE\` INT64,
  \`STS_CODE\` STRING,
  \`LSE_ID\` INT64,
  \`EXCEPTION_YN\` STRING,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`PRICE_NEGOTIATED\` FLOAT64,
  \`PRICE_LEVEL_IND\` STRING,
  \`PRICE_TYPE\` STRING,
  \`CURRENCY_CODE\` STRING,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`DATE_TERMINATED\` DATE,
  \`START_DATE\` DATE,
  \`END_DATE\` DATE,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`PRICE_LIST_ID\` INT64,
  \`PRICE_LIST_LINE_ID\` INT64,
  \`LINE_LIST_PRICE\` FLOAT64,
  \`ITEM_TO_PRICE_YN\` STRING,
  \`CUST_ACCT_ID\` INT64,
  \`BILL_TO_SITE_USE_ID\` INT64,
  \`PAYMENT_TERM_ID\` INT64,
  \`DATE_CANCELLED\` DATE,
  \`ANNUALIZED_FACTOR\` FLOAT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKC_K_LINES_B.json" "$BQ_PROJECT:$BQ_DATASET.OKC_K_LINES_B" "$RELEASE_URI/data/OKC_K_LINES_B/*.parquet"
fi

# OKC_K_LINES_TL: 2,505,907 rows
if want OKC_K_LINES_TL; then
echo "OKC_K_LINES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKC_K_LINES_TL\` (
  \`ID\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`SFWT_FLAG\` STRING,
  \`NAME\` STRING,
  \`ITEM_DESCRIPTION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKC_K_LINES_TL.json" "$BQ_PROJECT:$BQ_DATASET.OKC_K_LINES_TL" "$RELEASE_URI/data/OKC_K_LINES_TL/*.parquet"
fi

# OKC_K_PARTY_ROLES_B: 3,222,606 rows
if want OKC_K_PARTY_ROLES_B; then
echo "OKC_K_PARTY_ROLES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKC_K_PARTY_ROLES_B\` (
  \`ID\` INT64,
  \`CHR_ID\` INT64,
  \`CLE_ID\` INT64,
  \`DNZ_CHR_ID\` INT64,
  \`RLE_CODE\` STRING,
  \`OBJECT1_ID1\` STRING,
  \`OBJECT1_ID2\` STRING,
  \`JTOT_OBJECT1_CODE\` STRING,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PRIMARY_YN\` STRING,
  \`BILL_TO_SITE_USE_ID\` INT64,
  \`CUST_ACCT_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKC_K_PARTY_ROLES_B.json" "$BQ_PROJECT:$BQ_DATASET.OKC_K_PARTY_ROLES_B" "$RELEASE_URI/data/OKC_K_PARTY_ROLES_B/*.parquet"
fi

# OKC_K_PARTY_ROLES_TL: 3,222,606 rows
if want OKC_K_PARTY_ROLES_TL; then
echo "OKC_K_PARTY_ROLES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKC_K_PARTY_ROLES_TL\` (
  \`ID\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`SFWT_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKC_K_PARTY_ROLES_TL.json" "$BQ_PROJECT:$BQ_DATASET.OKC_K_PARTY_ROLES_TL" "$RELEASE_URI/data/OKC_K_PARTY_ROLES_TL/*.parquet"
fi

# OKC_STATUSES_B: 8 rows
if want OKC_STATUSES_B; then
echo "OKC_STATUSES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKC_STATUSES_B\` (
  \`CODE\` STRING,
  \`STE_CODE\` STRING,
  \`DEFAULT_YN\` STRING,
  \`START_DATE\` DATE,
  \`END_DATE\` DATE,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKC_STATUSES_B.json" "$BQ_PROJECT:$BQ_DATASET.OKC_STATUSES_B" "$RELEASE_URI/data/OKC_STATUSES_B/*.parquet"
fi

# OKC_STATUSES_TL: 8 rows
if want OKC_STATUSES_TL; then
echo "OKC_STATUSES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKC_STATUSES_TL\` (
  \`CODE\` STRING,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`SFWT_FLAG\` STRING,
  \`MEANING\` STRING,
  \`DESCRIPTION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKC_STATUSES_TL.json" "$BQ_PROJECT:$BQ_DATASET.OKC_STATUSES_TL" "$RELEASE_URI/data/OKC_STATUSES_TL/*.parquet"
fi

# OKS_BILL_CONT_LINES: 5,907,180 rows
if want OKS_BILL_CONT_LINES; then
echo "OKS_BILL_CONT_LINES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKS_BILL_CONT_LINES\` (
  \`ID\` INT64,
  \`CLE_ID\` INT64,
  \`BTN_ID\` INT64,
  \`DATE_BILLED_FROM\` DATE,
  \`DATE_BILLED_TO\` DATE,
  \`SENT_YN\` STRING,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`BILL_ACTION\` STRING,
  \`DATE_NEXT_INVOICE\` DATE,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING,
  \`CURRENCY_CODE\` STRING,
  \`AVERAGED_YN\` STRING,
  \`SETTLED_YN\` STRING,
  \`AMOUNT\` FLOAT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKS_BILL_CONT_LINES.json" "$BQ_PROJECT:$BQ_DATASET.OKS_BILL_CONT_LINES" "$RELEASE_URI/data/OKS_BILL_CONT_LINES/*.parquet"
fi

# OKS_BILL_TXN_LINES: 5,907,180 rows
if want OKS_BILL_TXN_LINES; then
echo "OKS_BILL_TXN_LINES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKS_BILL_TXN_LINES\` (
  \`ID\` INT64,
  \`BTN_ID\` INT64,
  \`BSL_ID\` INT64,
  \`BCL_ID\` INT64,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`BILL_INSTANCE_NUMBER\` INT64,
  \`TRX_LINE_AMOUNT\` STRING,
  \`TRX_LINE_TAX_AMOUNT\` FLOAT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`TRX_DATE\` DATE,
  \`TRX_NUMBER\` STRING,
  \`TRX_CLASS\` STRING,
  \`TRX_AMOUNT\` FLOAT64,
  \`SPLIT_FLAG\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKS_BILL_TXN_LINES.json" "$BQ_PROJECT:$BQ_DATASET.OKS_BILL_TXN_LINES" "$RELEASE_URI/data/OKS_BILL_TXN_LINES/*.parquet"
fi

# OKS_K_LINES_B: 2,505,907 rows
if want OKS_K_LINES_B; then
echo "OKS_K_LINES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKS_K_LINES_B\` (
  \`ID\` INT64,
  \`CLE_ID\` INT64,
  \`DNZ_CHR_ID\` INT64,
  \`DISCOUNT_LIST\` INT64,
  \`ACCT_RULE_ID\` INT64,
  \`PAYMENT_TYPE\` STRING,
  \`CC_BANK_ACCT_ID\` INT64,
  \`GRACE_DURATION\` FLOAT64,
  \`GRACE_PERIOD\` STRING,
  \`INV_PRINT_FLAG\` STRING,
  \`PRICE_UOM\` STRING,
  \`TAX_AMOUNT\` FLOAT64,
  \`TAX_INCLUSIVE_YN\` STRING,
  \`TAX_STATUS\` STRING,
  \`SERVICE_PRICE\` FLOAT64,
  \`CLVL_LIST_PRICE\` FLOAT64,
  \`CLVL_QUANTITY\` FLOAT64,
  \`CLVL_EXTENDED_AMT\` FLOAT64,
  \`CLVL_UOM_CODE\` STRING,
  \`BILLING_SCHEDULE_TYPE\` STRING,
  \`FULL_CREDIT\` STRING,
  \`PRORATE\` STRING,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`REQUEST_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKS_K_LINES_B.json" "$BQ_PROJECT:$BQ_DATASET.OKS_K_LINES_B" "$RELEASE_URI/data/OKS_K_LINES_B/*.parquet"
fi

# OKS_K_LINES_TL: 2,505,907 rows
if want OKS_K_LINES_TL; then
echo "OKS_K_LINES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKS_K_LINES_TL\` (
  \`ID\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`SFWT_FLAG\` STRING,
  \`INVOICE_TEXT\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKS_K_LINES_TL.json" "$BQ_PROJECT:$BQ_DATASET.OKS_K_LINES_TL" "$RELEASE_URI/data/OKS_K_LINES_TL/*.parquet"
fi

# OKS_LEVEL_ELEMENTS: 6,289,622 rows
if want OKS_LEVEL_ELEMENTS; then
echo "OKS_LEVEL_ELEMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKS_LEVEL_ELEMENTS\` (
  \`ID\` INT64,
  \`SEQUENCE_NUMBER\` STRING,
  \`DATE_START\` DATE,
  \`AMOUNT\` FLOAT64,
  \`DATE_RECEIVABLE_GL\` DATE,
  \`DATE_TRANSACTION\` DATE,
  \`DATE_DUE\` DATE,
  \`DATE_TO_INTERFACE\` DATE,
  \`DATE_COMPLETED\` DATE,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`RUL_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`CLE_ID\` INT64,
  \`DNZ_CHR_ID\` INT64,
  \`PARENT_CLE_ID\` INT64,
  \`DATE_END\` DATE
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKS_LEVEL_ELEMENTS.json" "$BQ_PROJECT:$BQ_DATASET.OKS_LEVEL_ELEMENTS" "$RELEASE_URI/data/OKS_LEVEL_ELEMENTS/*.parquet"
fi

# OKS_STREAM_LEVELS_B: 2,505,907 rows
if want OKS_STREAM_LEVELS_B; then
echo "OKS_STREAM_LEVELS_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.OKS_STREAM_LEVELS_B\` (
  \`ID\` INT64,
  \`CHR_ID\` INT64,
  \`CLE_ID\` INT64,
  \`DNZ_CHR_ID\` INT64,
  \`SEQUENCE_NO\` INT64,
  \`UOM_CODE\` STRING,
  \`START_DATE\` DATE,
  \`END_DATE\` DATE,
  \`LEVEL_PERIODS\` INT64,
  \`UOM_PER_PERIOD\` FLOAT64,
  \`ADVANCE_PERIODS\` INT64,
  \`LEVEL_AMOUNT\` FLOAT64,
  \`INVOICE_OFFSET_DAYS\` INT64,
  \`INTERFACE_OFFSET_DAYS\` INT64,
  \`DUE_ARR_YN\` STRING,
  \`AMOUNT\` FLOAT64,
  \`LINES_DETAILED_YN\` STRING,
  \`OBJECT_VERSION_NUMBER\` INT64,
  \`REQUEST_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/OKS_STREAM_LEVELS_B.json" "$BQ_PROJECT:$BQ_DATASET.OKS_STREAM_LEVELS_B" "$RELEASE_URI/data/OKS_STREAM_LEVELS_B/*.parquet"
fi

# QP_LIST_HEADERS_B: 33,855 rows
if want QP_LIST_HEADERS_B; then
echo "QP_LIST_HEADERS_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.QP_LIST_HEADERS_B\` (
  \`LIST_HEADER_ID\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`LIST_TYPE_CODE\` STRING,
  \`START_DATE_ACTIVE\` DATE,
  \`END_DATE_ACTIVE\` DATE,
  \`CURRENCY_CODE\` STRING,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/QP_LIST_HEADERS_B.json" "$BQ_PROJECT:$BQ_DATASET.QP_LIST_HEADERS_B" "$RELEASE_URI/data/QP_LIST_HEADERS_B/*.parquet"
fi

# QP_LIST_HEADERS_TL: 33,855 rows
if want QP_LIST_HEADERS_TL; then
echo "QP_LIST_HEADERS_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.QP_LIST_HEADERS_TL\` (
  \`LIST_HEADER_ID\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`NAME\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/QP_LIST_HEADERS_TL.json" "$BQ_PROJECT:$BQ_DATASET.QP_LIST_HEADERS_TL" "$RELEASE_URI/data/QP_LIST_HEADERS_TL/*.parquet"
fi

# QP_LIST_LINES: 34,103 rows
if want QP_LIST_LINES; then
echo "QP_LIST_LINES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.QP_LIST_LINES\` (
  \`LIST_LINE_ID\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`LIST_LINE_TYPE_CODE\` STRING,
  \`START_DATE_ACTIVE\` DATE,
  \`END_DATE_ACTIVE\` DATE,
  \`AUTOMATIC_FLAG\` STRING,
  \`MODIFIER_LEVEL_CODE\` STRING,
  \`ARITHMETIC_OPERATOR\` STRING,
  \`OPERAND\` FLOAT64,
  \`ATTRIBUTE1\` STRING,
  \`ATTRIBUTE2\` STRING,
  \`ATTRIBUTE3\` STRING,
  \`ATTRIBUTE4\` STRING,
  \`ATTRIBUTE5\` STRING,
  \`ATTRIBUTE6\` STRING,
  \`ATTRIBUTE7\` STRING,
  \`ATTRIBUTE8\` STRING,
  \`ATTRIBUTE9\` STRING,
  \`ATTRIBUTE10\` STRING,
  \`ATTRIBUTE11\` STRING,
  \`ATTRIBUTE12\` STRING,
  \`ATTRIBUTE13\` STRING,
  \`ATTRIBUTE14\` STRING,
  \`ATTRIBUTE15\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/QP_LIST_LINES.json" "$BQ_PROJECT:$BQ_DATASET.QP_LIST_LINES" "$RELEASE_URI/data/QP_LIST_LINES/*.parquet"
fi

# QP_PRICING_ATTRIBUTES: 34,211 rows
if want QP_PRICING_ATTRIBUTES; then
echo "QP_PRICING_ATTRIBUTES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.QP_PRICING_ATTRIBUTES\` (
  \`PRICING_ATTRIBUTE_ID\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`REQUEST_ID\` INT64,
  \`LIST_LINE_ID\` INT64,
  \`EXCLUDER_FLAG\` STRING,
  \`PRODUCT_ATTRIBUTE_CONTEXT\` STRING,
  \`PRODUCT_ATTRIBUTE\` STRING,
  \`PRODUCT_ATTR_VALUE\` STRING,
  \`PRICING_ATTRIBUTE_CONTEXT\` STRING,
  \`PRICING_ATTRIBUTE\` STRING,
  \`PRICING_ATTR_VALUE_FROM\` STRING,
  \`ATTRIBUTE_GROUPING_NO\` INT64,
  \`PRODUCT_ATTRIBUTE_DATATYPE\` STRING,
  \`PRICING_ATTRIBUTE_DATATYPE\` STRING,
  \`COMPARISON_OPERATOR_CODE\` STRING,
  \`LIST_HEADER_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/QP_PRICING_ATTRIBUTES.json" "$BQ_PROJECT:$BQ_DATASET.QP_PRICING_ATTRIBUTES" "$RELEASE_URI/data/QP_PRICING_ATTRIBUTES/*.parquet"
fi

# QP_QUALIFIERS: 2 rows
if want QP_QUALIFIERS; then
echo "QP_QUALIFIERS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.QP_QUALIFIERS\` (
  \`QUALIFIER_ID\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`QUALIFIER_GROUPING_NO\` INT64,
  \`QUALIFIER_CONTEXT\` STRING,
  \`QUALIFIER_ATTRIBUTE\` STRING,
  \`QUALIFIER_ATTR_VALUE\` STRING,
  \`COMPARISON_OPERATOR_CODE\` STRING,
  \`EXCLUDER_FLAG\` STRING,
  \`START_DATE_ACTIVE\` DATE,
  \`END_DATE_ACTIVE\` DATE,
  \`QUALIFIER_PRECEDENCE\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`LIST_LINE_ID\` INT64,
  \`QUALIFIER_DATATYPE\` STRING,
  \`ACTIVE_FLAG\` STRING,
  \`LIST_TYPE_CODE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/QP_QUALIFIERS.json" "$BQ_PROJECT:$BQ_DATASET.QP_QUALIFIERS" "$RELEASE_URI/data/QP_QUALIFIERS/*.parquet"
fi

# RA_BATCH_SOURCES_ALL: 3 rows
if want RA_BATCH_SOURCES_ALL; then
echo "RA_BATCH_SOURCES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.RA_BATCH_SOURCES_ALL\` (
  \`BATCH_SOURCE_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`NAME\` STRING,
  \`ORG_ID\` INT64,
  \`DESCRIPTION\` STRING,
  \`BATCH_SOURCE_TYPE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/RA_BATCH_SOURCES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.RA_BATCH_SOURCES_ALL" "$RELEASE_URI/data/RA_BATCH_SOURCES_ALL/*.parquet"
fi

# RA_CUSTOMER_TRX_ALL: 88,806,376 rows
if want RA_CUSTOMER_TRX_ALL; then
echo "RA_CUSTOMER_TRX_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.RA_CUSTOMER_TRX_ALL\` (
  \`CUSTOMER_TRX_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`TRX_NUMBER\` STRING,
  \`CUST_TRX_TYPE_ID\` INT64,
  \`TRX_DATE\` DATE,
  \`SET_OF_BOOKS_ID\` INT64,
  \`BATCH_SOURCE_ID\` INT64,
  \`BILL_TO_CUSTOMER_ID\` INT64,
  \`BILL_TO_SITE_USE_ID\` INT64,
  \`SHIP_TO_SITE_USE_ID\` INT64,
  \`TERM_ID\` INT64,
  \`PREVIOUS_CUSTOMER_TRX_ID\` INT64,
  \`INVOICE_CURRENCY_CODE\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`COMPLETE_FLAG\` STRING,
  \`INTERFACE_HEADER_ATTRIBUTE1\` STRING,
  \`INTERFACE_HEADER_CONTEXT\` STRING,
  \`CREATED_FROM\` STRING,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/RA_CUSTOMER_TRX_ALL.json" "$BQ_PROJECT:$BQ_DATASET.RA_CUSTOMER_TRX_ALL" "$RELEASE_URI/data/RA_CUSTOMER_TRX_ALL/*.parquet"
fi

# RA_CUSTOMER_TRX_LINES_ALL: 535,185,608 rows
if want RA_CUSTOMER_TRX_LINES_ALL; then
echo "RA_CUSTOMER_TRX_LINES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.RA_CUSTOMER_TRX_LINES_ALL\` (
  \`CUSTOMER_TRX_LINE_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`CUSTOMER_TRX_ID\` INT64,
  \`LINE_NUMBER\` INT64,
  \`SET_OF_BOOKS_ID\` INT64,
  \`INVENTORY_ITEM_ID\` INT64,
  \`DESCRIPTION\` STRING,
  \`QUANTITY_INVOICED\` INT64,
  \`UNIT_SELLING_PRICE\` FLOAT64,
  \`LINE_TYPE\` STRING,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`EXTENDED_AMOUNT\` FLOAT64,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/RA_CUSTOMER_TRX_LINES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.RA_CUSTOMER_TRX_LINES_ALL" "$RELEASE_URI/data/RA_CUSTOMER_TRX_LINES_ALL/*.parquet"
fi

# RA_CUST_TRX_LINE_GL_DIST_ALL: 245,955,258 rows
if want RA_CUST_TRX_LINE_GL_DIST_ALL; then
echo "RA_CUST_TRX_LINE_GL_DIST_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.RA_CUST_TRX_LINE_GL_DIST_ALL\` (
  \`CUST_TRX_LINE_GL_DIST_ID\` INT64,
  \`CUSTOMER_TRX_LINE_ID\` INT64,
  \`CODE_COMBINATION_ID\` INT64,
  \`SET_OF_BOOKS_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`AMOUNT\` FLOAT64,
  \`GL_DATE\` DATE,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`POSTING_CONTROL_ID\` INT64,
  \`ACCOUNT_CLASS\` STRING,
  \`CUSTOMER_TRX_ID\` INT64,
  \`ACCOUNT_SET_FLAG\` STRING,
  \`ORG_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/RA_CUST_TRX_LINE_GL_DIST_ALL.json" "$BQ_PROJECT:$BQ_DATASET.RA_CUST_TRX_LINE_GL_DIST_ALL" "$RELEASE_URI/data/RA_CUST_TRX_LINE_GL_DIST_ALL/*.parquet"
fi

# RA_CUST_TRX_TYPES_ALL: 4 rows
if want RA_CUST_TRX_TYPES_ALL; then
echo "RA_CUST_TRX_TYPES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.RA_CUST_TRX_TYPES_ALL\` (
  \`CUST_TRX_TYPE_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`POST_TO_GL\` STRING,
  \`ACCOUNTING_AFFECT_FLAG\` STRING,
  \`NAME\` STRING,
  \`DESCRIPTION\` STRING,
  \`TYPE\` STRING,
  \`DEFAULT_PRINTING_OPTION\` STRING,
  \`DEFAULT_STATUS\` STRING,
  \`ALLOW_FREIGHT_FLAG\` STRING,
  \`ALLOW_OVERAPPLICATION_FLAG\` STRING,
  \`CREATION_SIGN\` STRING,
  \`START_DATE\` DATE,
  \`TAX_CALCULATION_FLAG\` STRING,
  \`NATURAL_APPLICATION_ONLY_FLAG\` STRING,
  \`ORG_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/RA_CUST_TRX_TYPES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.RA_CUST_TRX_TYPES_ALL" "$RELEASE_URI/data/RA_CUST_TRX_TYPES_ALL/*.parquet"
fi

# RA_INTERFACE_LINES_ALL: 0 rows
if want RA_INTERFACE_LINES_ALL; then
echo "RA_INTERFACE_LINES_ALL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.RA_INTERFACE_LINES_ALL\` (
  \`INTERFACE_LINE_ID\` INT64,
  \`INTERFACE_LINE_CONTEXT\` STRING,
  \`INTERFACE_LINE_ATTRIBUTE1\` STRING,
  \`BATCH_SOURCE_NAME\` STRING,
  \`LINE_TYPE\` STRING,
  \`DESCRIPTION\` STRING,
  \`CURRENCY_CODE\` STRING,
  \`AMOUNT\` FLOAT64,
  \`ORIG_SYSTEM_BILL_CUSTOMER_ID\` INT64,
  \`CONVERSION_TYPE\` STRING,
  \`TRX_DATE\` DATETIME,
  \`INTERFACE_STATUS\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`ORG_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/RA_INTERFACE_LINES_ALL.json" "$BQ_PROJECT:$BQ_DATASET.RA_INTERFACE_LINES_ALL" "$RELEASE_URI/data/RA_INTERFACE_LINES_ALL/*.parquet"
fi

# RA_TERMS_B: 3 rows
if want RA_TERMS_B; then
echo "RA_TERMS_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.RA_TERMS_B\` (
  \`TERM_ID\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`START_DATE_ACTIVE\` DATE,
  \`BASE_AMOUNT\` INT64,
  \`CALC_DISCOUNT_ON_LINES_FLAG\` STRING,
  \`FIRST_INSTALLMENT_CODE\` STRING,
  \`IN_USE\` STRING,
  \`PARTIAL_DISCOUNT_FLAG\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/RA_TERMS_B.json" "$BQ_PROJECT:$BQ_DATASET.RA_TERMS_B" "$RELEASE_URI/data/RA_TERMS_B/*.parquet"
fi

# RA_TERMS_LINES: 3 rows
if want RA_TERMS_LINES; then
echo "RA_TERMS_LINES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.RA_TERMS_LINES\` (
  \`TERM_ID\` INT64,
  \`SEQUENCE_NUM\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`RELATIVE_AMOUNT\` INT64,
  \`DUE_DAYS\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/RA_TERMS_LINES.json" "$BQ_PROJECT:$BQ_DATASET.RA_TERMS_LINES" "$RELEASE_URI/data/RA_TERMS_LINES/*.parquet"
fi

# RA_TERMS_TL: 3 rows
if want RA_TERMS_TL; then
echo "RA_TERMS_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.RA_TERMS_TL\` (
  \`TERM_ID\` INT64,
  \`DESCRIPTION\` STRING,
  \`NAME\` STRING,
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/RA_TERMS_TL.json" "$BQ_PROJECT:$BQ_DATASET.RA_TERMS_TL" "$RELEASE_URI/data/RA_TERMS_TL/*.parquet"
fi

# XLA_AE_HEADERS: 166,682,629 rows
if want XLA_AE_HEADERS; then
echo "XLA_AE_HEADERS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XLA_AE_HEADERS\` (
  \`AE_HEADER_ID\` INT64,
  \`APPLICATION_ID\` INT64,
  \`LEDGER_ID\` INT64,
  \`ENTITY_ID\` INT64,
  \`EVENT_ID\` INT64,
  \`EVENT_TYPE_CODE\` STRING,
  \`ACCOUNTING_DATE\` DATE,
  \`GL_TRANSFER_STATUS_CODE\` STRING,
  \`JE_CATEGORY_NAME\` STRING,
  \`ACCOUNTING_ENTRY_STATUS_CODE\` STRING,
  \`ACCOUNTING_ENTRY_TYPE_CODE\` STRING,
  \`DESCRIPTION\` STRING,
  \`BALANCE_TYPE_CODE\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`REQUEST_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XLA_AE_HEADERS.json" "$BQ_PROJECT:$BQ_DATASET.XLA_AE_HEADERS" "$RELEASE_URI/data/XLA_AE_HEADERS/*.parquet"
fi

# XLA_AE_LINES: 412,340,432 rows
if want XLA_AE_LINES; then
echo "XLA_AE_LINES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XLA_AE_LINES\` (
  \`AE_HEADER_ID\` INT64,
  \`AE_LINE_NUM\` INT64,
  \`APPLICATION_ID\` INT64,
  \`CODE_COMBINATION_ID\` INT64,
  \`GL_SL_LINK_ID\` INT64,
  \`ACCOUNTING_CLASS_CODE\` STRING,
  \`PARTY_ID\` INT64,
  \`PARTY_TYPE_CODE\` STRING,
  \`ENTERED_DR\` FLOAT64,
  \`ENTERED_CR\` FLOAT64,
  \`ACCOUNTED_DR\` FLOAT64,
  \`ACCOUNTED_CR\` FLOAT64,
  \`CURRENCY_CODE\` STRING,
  \`GL_SL_LINK_TABLE\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`REQUEST_ID\` INT64,
  \`ACCOUNTING_DATE\` DATE,
  \`LEDGER_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XLA_AE_LINES.json" "$BQ_PROJECT:$BQ_DATASET.XLA_AE_LINES" "$RELEASE_URI/data/XLA_AE_LINES/*.parquet"
fi

# XLA_DISTRIBUTION_LINKS: 412,340,432 rows
if want XLA_DISTRIBUTION_LINKS; then
echo "XLA_DISTRIBUTION_LINKS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XLA_DISTRIBUTION_LINKS\` (
  \`APPLICATION_ID\` INT64,
  \`EVENT_ID\` INT64,
  \`AE_HEADER_ID\` INT64,
  \`AE_LINE_NUM\` INT64,
  \`SOURCE_DISTRIBUTION_TYPE\` STRING,
  \`SOURCE_DISTRIBUTION_ID_NUM_1\` INT64,
  \`ACCOUNTING_LINE_CODE\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XLA_DISTRIBUTION_LINKS.json" "$BQ_PROJECT:$BQ_DATASET.XLA_DISTRIBUTION_LINKS" "$RELEASE_URI/data/XLA_DISTRIBUTION_LINKS/*.parquet"
fi

# XLA_EVENTS: 166,682,629 rows
if want XLA_EVENTS; then
echo "XLA_EVENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XLA_EVENTS\` (
  \`EVENT_ID\` INT64,
  \`APPLICATION_ID\` INT64,
  \`EVENT_TYPE_CODE\` STRING,
  \`EVENT_DATE\` DATE,
  \`ENTITY_ID\` INT64,
  \`EVENT_STATUS_CODE\` STRING,
  \`PROCESS_STATUS_CODE\` STRING,
  \`EVENT_NUMBER\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`REQUEST_ID\` INT64,
  \`TRANSACTION_DATE\` DATE
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XLA_EVENTS.json" "$BQ_PROJECT:$BQ_DATASET.XLA_EVENTS" "$RELEASE_URI/data/XLA_EVENTS/*.parquet"
fi

# XLA_EVENT_TYPES_B: 5 rows
if want XLA_EVENT_TYPES_B; then
echo "XLA_EVENT_TYPES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XLA_EVENT_TYPES_B\` (
  \`APPLICATION_ID\` INT64,
  \`ENTITY_CODE\` STRING,
  \`EVENT_CLASS_CODE\` STRING,
  \`EVENT_TYPE_CODE\` STRING,
  \`ACCOUNTING_FLAG\` STRING,
  \`TAX_FLAG\` STRING,
  \`ENABLED_FLAG\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XLA_EVENT_TYPES_B.json" "$BQ_PROJECT:$BQ_DATASET.XLA_EVENT_TYPES_B" "$RELEASE_URI/data/XLA_EVENT_TYPES_B/*.parquet"
fi

# XLA_EVENT_TYPES_TL: 5 rows
if want XLA_EVENT_TYPES_TL; then
echo "XLA_EVENT_TYPES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XLA_EVENT_TYPES_TL\` (
  \`APPLICATION_ID\` INT64,
  \`ENTITY_CODE\` STRING,
  \`EVENT_CLASS_CODE\` STRING,
  \`EVENT_TYPE_CODE\` STRING,
  \`LANGUAGE\` STRING,
  \`NAME\` STRING,
  \`DESCRIPTION\` STRING,
  \`SOURCE_LANG\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XLA_EVENT_TYPES_TL.json" "$BQ_PROJECT:$BQ_DATASET.XLA_EVENT_TYPES_TL" "$RELEASE_URI/data/XLA_EVENT_TYPES_TL/*.parquet"
fi

# XLA_TRANSACTION_ENTITIES: 165,767,504 rows
if want XLA_TRANSACTION_ENTITIES; then
echo "XLA_TRANSACTION_ENTITIES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XLA_TRANSACTION_ENTITIES\` (
  \`ENTITY_ID\` INT64,
  \`APPLICATION_ID\` INT64,
  \`ENTITY_CODE\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`SOURCE_ID_INT_1\` INT64,
  \`SECURITY_ID_INT_1\` INT64,
  \`LEDGER_ID\` INT64,
  \`SOURCE_APPLICATION_ID\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XLA_TRANSACTION_ENTITIES.json" "$BQ_PROJECT:$BQ_DATASET.XLA_TRANSACTION_ENTITIES" "$RELEASE_URI/data/XLA_TRANSACTION_ENTITIES/*.parquet"
fi

# XX_AUDIT_TRAIL: 282,177 rows
if want XX_AUDIT_TRAIL; then
echo "XX_AUDIT_TRAIL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_AUDIT_TRAIL\` (
  \`AUDIT_ID\` INT64,
  \`SOURCE_TABLE\` STRING,
  \`SOURCE_KEY_NAME\` STRING,
  \`SOURCE_KEY_VALUE\` STRING,
  \`COLUMN_NAME\` STRING,
  \`OLD_VALUE\` STRING,
  \`NEW_VALUE\` STRING,
  \`CHANGE_TYPE\` STRING,
  \`CHANGE_REASON\` STRING,
  \`TICKET_REFERENCE\` STRING,
  \`CHANGED_DATE\` DATETIME,
  \`CHANGED_BY\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_AUDIT_TRAIL.json" "$BQ_PROJECT:$BQ_DATASET.XX_AUDIT_TRAIL" "$RELEASE_URI/data/XX_AUDIT_TRAIL/*.parquet"
fi

# XX_CAMPAIGN_AUTHORITY_EVENTS: 85,454 rows
if want XX_CAMPAIGN_AUTHORITY_EVENTS; then
echo "XX_CAMPAIGN_AUTHORITY_EVENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_CAMPAIGN_AUTHORITY_EVENTS\` (
  \`EVENT_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`EVENT_TYPE_CODE\` STRING,
  \`EVENT_AMOUNT\` FLOAT64,
  \`EFFECTIVE_DATE\` DATETIME,
  \`POLICY_VERSION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_CAMPAIGN_AUTHORITY_EVENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_CAMPAIGN_AUTHORITY_EVENTS" "$RELEASE_URI/data/XX_CAMPAIGN_AUTHORITY_EVENTS/*.parquet"
fi

# XX_CAMPAIGN_BUDGET_CREDITS: 34,277 rows
if want XX_CAMPAIGN_BUDGET_CREDITS; then
echo "XX_CAMPAIGN_BUDGET_CREDITS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_CAMPAIGN_BUDGET_CREDITS\` (
  \`CREDIT_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`CREDIT_AMOUNT\` FLOAT64,
  \`COMMITMENT_COUNT\` INT64,
  \`EARLIEST_RELEASED_DATE\` DATETIME,
  \`LATEST_RELEASED_DATE\` DATETIME,
  \`DUE_DATE\` DATETIME,
  \`POSTED_DATE\` DATETIME,
  \`RECEIVED_DATE\` DATETIME,
  \`BATCH_NAME\` STRING,
  \`SCHEDULE_VERSION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_CAMPAIGN_BUDGET_CREDITS.json" "$BQ_PROJECT:$BQ_DATASET.XX_CAMPAIGN_BUDGET_CREDITS" "$RELEASE_URI/data/XX_CAMPAIGN_BUDGET_CREDITS/*.parquet"
fi

# XX_CARD_FINGERPRINTS: 7,377,322 rows
if want XX_CARD_FINGERPRINTS; then
echo "XX_CARD_FINGERPRINTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_CARD_FINGERPRINTS\` (
  \`CARD_FINGERPRINT_ID\` INT64,
  \`FINGERPRINT_HASH\` STRING,
  \`FIRST_SEEN_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_CARD_FINGERPRINTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_CARD_FINGERPRINTS" "$RELEASE_URI/data/XX_CARD_FINGERPRINTS/*.parquet"
fi

# XX_CARD_VERIFICATIONS: 2,671,548 rows
if want XX_CARD_VERIFICATIONS; then
echo "XX_CARD_VERIFICATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_CARD_VERIFICATIONS\` (
  \`VERIFICATION_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`DEVICE_ID\` INT64,
  \`IP_ADDRESS_ID\` INT64,
  \`CARD_FINGERPRINT_ID\` INT64,
  \`CARD_BIN\` INT64,
  \`INSTRUMENT_TYPE_CODE\` STRING,
  \`VERIFY_DATE\` DATETIME,
  \`AMOUNT\` FLOAT64,
  \`STATUS_CODE\` STRING,
  \`RESPONSE_CODE\` STRING,
  \`PAYMENT_INSTRUMENT_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_CARD_VERIFICATIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_CARD_VERIFICATIONS" "$RELEASE_URI/data/XX_CARD_VERIFICATIONS/*.parquet"
fi

# XX_COURIER_ACCOUNT_EVENTS: 9,802 rows
if want XX_COURIER_ACCOUNT_EVENTS; then
echo "XX_COURIER_ACCOUNT_EVENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_COURIER_ACCOUNT_EVENTS\` (
  \`EVENT_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`EVENT_AT\` DATETIME,
  \`KIND\` STRING,
  \`REASON_CODE\` STRING,
  \`TRAILING_DELIVERIES\` INT64,
  \`TRAILING_VIOLATIONS\` INT64,
  \`COMPLETION_RATE\` FLOAT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_COURIER_ACCOUNT_EVENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_COURIER_ACCOUNT_EVENTS" "$RELEASE_URI/data/XX_COURIER_ACCOUNT_EVENTS/*.parquet"
fi

# XX_COURIER_APPLICATIONS: 40,167 rows
if want XX_COURIER_APPLICATIONS; then
echo "XX_COURIER_APPLICATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_COURIER_APPLICATIONS\` (
  \`APPLICATION_ID\` INT64,
  \`APPLIED_AT\` DATETIME,
  \`DECIDED_AT\` DATETIME,
  \`DECISION\` STRING,
  \`VENDOR_ID\` INT64,
  \`DEVICE_ID\` INT64,
  \`MATCHED_VENDOR_ID\` INT64,
  \`MATCH_SIGNAL\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_COURIER_APPLICATIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_COURIER_APPLICATIONS" "$RELEASE_URI/data/XX_COURIER_APPLICATIONS/*.parquet"
fi

# XX_COURIER_APP_SESSIONS: 6,075,323 rows
if want XX_COURIER_APP_SESSIONS; then
echo "XX_COURIER_APP_SESSIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_COURIER_APP_SESSIONS\` (
  \`SESSION_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`DEVICE_ID\` INT64,
  \`LOGGED_IN_AT\` DATETIME,
  \`LOGGED_OUT_AT\` DATETIME,
  \`END_REASON\` STRING,
  \`ACCESSIBILITY_SERVICE\` BOOLEAN,
  \`SCREEN_OVERLAY\` BOOLEAN,
  \`MODIFIED_CLIENT\` BOOLEAN
)
PARTITION BY DATETIME_TRUNC(\`LOGGED_IN_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_COURIER_APP_SESSIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_COURIER_APP_SESSIONS" "$RELEASE_URI/data/XX_COURIER_APP_SESSIONS/*.parquet"
fi

# XX_COURIER_DEVICES: 115,306 rows
if want XX_COURIER_DEVICES; then
echo "XX_COURIER_DEVICES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_COURIER_DEVICES\` (
  \`DEVICE_ID\` INT64,
  \`PLATFORM\` STRING,
  \`MANUFACTURER\` STRING,
  \`MODEL\` STRING,
  \`OS_VERSION\` STRING,
  \`FIRST_SEEN_AT\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_COURIER_DEVICES.json" "$BQ_PROJECT:$BQ_DATASET.XX_COURIER_DEVICES" "$RELEASE_URI/data/XX_COURIER_DEVICES/*.parquet"
fi

# XX_COURIER_EARNINGS: 69,510,237 rows
if want XX_COURIER_EARNINGS; then
echo "XX_COURIER_EARNINGS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_COURIER_EARNINGS\` (
  \`EARNING_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`EARNED_DATE\` DATETIME,
  \`BASE_PAY\` FLOAT64,
  \`TIP_AMOUNT\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_COURIER_EARNINGS.json" "$BQ_PROJECT:$BQ_DATASET.XX_COURIER_EARNINGS" "$RELEASE_URI/data/XX_COURIER_EARNINGS/*.parquet"
fi

# XX_COURIER_IDENTITY_CHECKS: 154,540 rows
if want XX_COURIER_IDENTITY_CHECKS; then
echo "XX_COURIER_IDENTITY_CHECKS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_COURIER_IDENTITY_CHECKS\` (
  \`CHECK_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`SESSION_ID\` INT64,
  \`DEVICE_ID\` INT64,
  \`REQUESTED_AT\` DATETIME,
  \`TRIGGER\` STRING,
  \`HEADER_ID\` INT64,
  \`OUTCOME\` STRING,
  \`COMPLETED_AT\` DATETIME,
  \`REVIEW_OUTCOME\` STRING,
  \`REVIEWED_AT\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_COURIER_IDENTITY_CHECKS.json" "$BQ_PROJECT:$BQ_DATASET.XX_COURIER_IDENTITY_CHECKS" "$RELEASE_URI/data/XX_COURIER_IDENTITY_CHECKS/*.parquet"
fi

# XX_COURIER_VIOLATIONS: 112,326 rows
if want XX_COURIER_VIOLATIONS; then
echo "XX_COURIER_VIOLATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_COURIER_VIOLATIONS\` (
  \`VIOLATION_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`DELIVERY_ASSIGNMENT_ID\` INT64,
  \`KIND\` STRING,
  \`ISSUED_AT\` DATETIME,
  \`SOURCE\` STRING,
  \`DISPUTED_AT\` DATETIME,
  \`DISPUTE_OUTCOME\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_COURIER_VIOLATIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_COURIER_VIOLATIONS" "$RELEASE_URI/data/XX_COURIER_VIOLATIONS/*.parquet"
fi

# XX_COURIER_WAITS: 21,842,232 rows
if want XX_COURIER_WAITS; then
echo "XX_COURIER_WAITS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_COURIER_WAITS\` (
  \`WAIT_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`MERCHANT_VENDOR_ID\` INT64,
  \`ARRIVED_DATE\` DATETIME,
  \`RELEASED_DATE\` DATETIME,
  \`WAIT_SECONDS\` INT64,
  \`THRESHOLD_SECONDS\` INT64,
  \`WAIT_PAY_ELIGIBLE_FLAG\` STRING,
  \`QUOTED_READY_DATE\` DATETIME,
  \`READY_REPORTED_DATE\` DATETIME,
  \`AVOIDABLE_WAIT_SECONDS\` INT64,
  \`REPORTED_BY_CODE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_COURIER_WAITS.json" "$BQ_PROJECT:$BQ_DATASET.XX_COURIER_WAITS" "$RELEASE_URI/data/XX_COURIER_WAITS/*.parquet"
fi

# XX_CUSTOMER_ACCOUNT_EVENTS: 818,350 rows
if want XX_CUSTOMER_ACCOUNT_EVENTS; then
echo "XX_CUSTOMER_ACCOUNT_EVENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_CUSTOMER_ACCOUNT_EVENTS\` (
  \`ACCOUNT_EVENT_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`EVENT_DATE\` DATETIME,
  \`EVENT_TYPE_CODE\` STRING,
  \`CHANNEL_CODE\` STRING,
  \`OUTCOME_CODE\` STRING,
  \`SESSION_ID\` INT64,
  \`DEVICE_ID\` INT64,
  \`IP_ADDRESS_ID\` INT64,
  \`OLD_VALUE_MASKED\` STRING,
  \`NEW_VALUE_MASKED\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_CUSTOMER_ACCOUNT_EVENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_CUSTOMER_ACCOUNT_EVENTS" "$RELEASE_URI/data/XX_CUSTOMER_ACCOUNT_EVENTS/*.parquet"
fi

# XX_CUSTOMER_DEVICES: 9,778,766 rows
if want XX_CUSTOMER_DEVICES; then
echo "XX_CUSTOMER_DEVICES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_CUSTOMER_DEVICES\` (
  \`CUSTOMER_DEVICE_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`DEVICE_ID\` INT64,
  \`FIRST_USED_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_CUSTOMER_DEVICES.json" "$BQ_PROJECT:$BQ_DATASET.XX_CUSTOMER_DEVICES" "$RELEASE_URI/data/XX_CUSTOMER_DEVICES/*.parquet"
fi

# XX_CUSTOMER_SESSIONS: 283,206,289 rows
if want XX_CUSTOMER_SESSIONS; then
echo "XX_CUSTOMER_SESSIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_CUSTOMER_SESSIONS\` (
  \`SESSION_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`DEVICE_ID\` INT64,
  \`IP_ADDRESS_ID\` INT64,
  \`START_DATE\` DATETIME,
  \`END_DATE\` DATETIME,
  \`SESSION_CONTEXT_CODE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_CUSTOMER_SESSIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_CUSTOMER_SESSIONS" "$RELEASE_URI/data/XX_CUSTOMER_SESSIONS/*.parquet"
fi

# XX_DELIVERY_ASSIGNMENTS: 72,820,396 rows
if want XX_DELIVERY_ASSIGNMENTS; then
echo "XX_DELIVERY_ASSIGNMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DELIVERY_ASSIGNMENTS\` (
  \`ASSIGNMENT_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`OFFER_ASSIGNMENT_ID\` INT64,
  \`ACCEPTED_AT\` DATETIME,
  \`ARRIVED_AT\` DATETIME,
  \`PICKUP_TAPPED_AT\` DATETIME,
  \`ENDED_AT\` DATETIME,
  \`END_REASON\` STRING,
  \`UNASSIGN_REASON_CODE\` STRING,
  \`COMPLETION_IMPACT\` BOOLEAN
)
PARTITION BY DATETIME_TRUNC(\`ACCEPTED_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DELIVERY_ASSIGNMENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_DELIVERY_ASSIGNMENTS" "$RELEASE_URI/data/XX_DELIVERY_ASSIGNMENTS/*.parquet"
fi

# XX_DELIVERY_ATTEMPTS: 1,971,172 rows
if want XX_DELIVERY_ATTEMPTS; then
echo "XX_DELIVERY_ATTEMPTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DELIVERY_ATTEMPTS\` (
  \`ATTEMPT_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`ATTEMPT_NUMBER\` INT64,
  \`ATTEMPT_DATE\` DATETIME,
  \`OUTCOME_CODE\` STRING,
  \`PHOTO_CAPTURED_FLAG\` STRING,
  \`CONTACT_ATTEMPTED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DELIVERY_ATTEMPTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_DELIVERY_ATTEMPTS" "$RELEASE_URI/data/XX_DELIVERY_ATTEMPTS/*.parquet"
fi

# XX_DELIVERY_LEGS: 69,510,237 rows
if want XX_DELIVERY_LEGS; then
echo "XX_DELIVERY_LEGS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DELIVERY_LEGS\` (
  \`DELIVERY_LEG_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`BATCH_REF\` INT64,
  \`PICKUP_ZONE_ID\` INT64,
  \`DROPOFF_ZONE_ID\` INT64,
  \`DISPATCHED_DATE\` DATETIME,
  \`ARRIVED_MERCHANT_DATE\` DATETIME,
  \`PICKED_UP_DATE\` DATETIME,
  \`DELIVERED_DATE\` DATETIME,
  \`DISTANCE_MILES\` FLOAT64,
  \`DURATION_SECONDS\` FLOAT64,
  \`TERMINUS_LATITUDE\` FLOAT64,
  \`TERMINUS_LONGITUDE\` FLOAT64,
  \`PING_COUNT\` INT64,
  \`MAX_INTER_PING_SPEED_MPH\` FLOAT64,
  \`PATH_HAVERSINE_RATIO\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DELIVERY_LEGS.json" "$BQ_PROJECT:$BQ_DATASET.XX_DELIVERY_LEGS" "$RELEASE_URI/data/XX_DELIVERY_LEGS/*.parquet"
fi

# XX_DEVICES: 9,394,404 rows
if want XX_DEVICES; then
echo "XX_DEVICES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DEVICES\` (
  \`DEVICE_ID\` INT64,
  \`PLATFORM_CODE\` STRING,
  \`DEVICE_FINGERPRINT\` STRING,
  \`FIRST_SEEN_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DEVICES.json" "$BQ_PROJECT:$BQ_DATASET.XX_DEVICES" "$RELEASE_URI/data/XX_DEVICES/*.parquet"
fi

# XX_DISPATCH_ASSIGNMENTS: 124,712,184 rows
if want XX_DISPATCH_ASSIGNMENTS; then
echo "XX_DISPATCH_ASSIGNMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DISPATCH_ASSIGNMENTS\` (
  \`ASSIGNMENT_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`ASSIGNMENT_SEQ\` INT64,
  \`OFFERED_DATE\` DATETIME,
  \`RESPONDED_DATE\` DATETIME,
  \`OUTCOME_CODE\` STRING,
  \`REASSIGNED_FLAG\` STRING,
  \`OFFER_PAY_AMOUNT\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DISPATCH_ASSIGNMENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_DISPATCH_ASSIGNMENTS" "$RELEASE_URI/data/XX_DISPATCH_ASSIGNMENTS/*.parquet"
fi

# XX_DISPUTES: 58,537 rows
if want XX_DISPUTES; then
echo "XX_DISPUTES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DISPUTES\` (
  \`DISPUTE_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`OPENED_DATE\` DATETIME,
  \`RESOLVED_DATE\` DATETIME,
  \`AMOUNT\` FLOAT64,
  \`REASON_CODE\` STRING,
  \`OUTCOME_CODE\` STRING,
  \`CHARGEBACK_RECEIPT_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DISPUTES.json" "$BQ_PROJECT:$BQ_DATASET.XX_DISPUTES" "$RELEASE_URI/data/XX_DISPUTES/*.parquet"
fi

# XX_DRIVER_LOCATION_OBSERVATIONS: 134,480,113 rows
if want XX_DRIVER_LOCATION_OBSERVATIONS; then
echo "XX_DRIVER_LOCATION_OBSERVATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DRIVER_LOCATION_OBSERVATIONS\` (
  \`OBSERVATION_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`OBSERVED_AT\` DATETIME,
  \`RECEIVED_AT\` DATETIME,
  \`ZONE_ID\` INT64,
  \`KIND\` STRING,
  \`ACCURACY_M\` FLOAT64,
  \`MOCK_LOCATION_FLAG\` STRING
)
PARTITION BY DATETIME_TRUNC(\`OBSERVED_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DRIVER_LOCATION_OBSERVATIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_DRIVER_LOCATION_OBSERVATIONS" "$RELEASE_URI/data/XX_DRIVER_LOCATION_OBSERVATIONS/*.parquet"
fi

# XX_DRIVER_PROFILES: 81,116 rows
if want XX_DRIVER_PROFILES; then
echo "XX_DRIVER_PROFILES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DRIVER_PROFILES\` (
  \`DRIVER_PROFILE_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`PARTY_ID\` INT64,
  \`VEHICLE_TYPE_CODE\` STRING,
  \`PREFERRED_LANGUAGE_CODE\` STRING,
  \`GENDER_CODE\` STRING,
  \`HOME_ZONE_ID\` INT64,
  \`ONBOARD_DATE\` DATE,
  \`INSTANT_PAY_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DRIVER_PROFILES.json" "$BQ_PROJECT:$BQ_DATASET.XX_DRIVER_PROFILES" "$RELEASE_URI/data/XX_DRIVER_PROFILES/*.parquet"
fi

# XX_DRIVER_QUESTS: 145,600 rows
if want XX_DRIVER_QUESTS; then
echo "XX_DRIVER_QUESTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DRIVER_QUESTS\` (
  \`QUEST_ID\` INT64,
  \`QUEST_NAME\` STRING,
  \`TARGET_DELIVERIES\` INT64,
  \`BONUS_AMOUNT\` FLOAT64,
  \`WINDOW_START_DATE\` DATETIME,
  \`WINDOW_END_DATE\` DATETIME,
  \`ELIGIBILITY_CODE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DRIVER_QUESTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_DRIVER_QUESTS" "$RELEASE_URI/data/XX_DRIVER_QUESTS/*.parquet"
fi

# XX_DRIVER_SHIFTS: 6,102,273 rows
if want XX_DRIVER_SHIFTS; then
echo "XX_DRIVER_SHIFTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_DRIVER_SHIFTS\` (
  \`SHIFT_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`START_DATE\` DATETIME,
  \`END_DATE\` DATETIME,
  \`TRIP_COUNT\` INT64,
  \`ENGAGED_SECONDS\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_DRIVER_SHIFTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_DRIVER_SHIFTS" "$RELEASE_URI/data/XX_DRIVER_SHIFTS/*.parquet"
fi

# XX_ENFORCEMENT_ACTIONS: 11,065 rows
if want XX_ENFORCEMENT_ACTIONS; then
echo "XX_ENFORCEMENT_ACTIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_ENFORCEMENT_ACTIONS\` (
  \`ACTION_ID\` INT64,
  \`ACTION_DATE\` DATETIME,
  \`PARTY_TYPE_CODE\` STRING,
  \`CUST_ACCOUNT_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`ACTION_CODE\` STRING,
  \`REASON_CODE\` STRING,
  \`CASE_REF\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_ENFORCEMENT_ACTIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_ENFORCEMENT_ACTIONS" "$RELEASE_URI/data/XX_ENFORCEMENT_ACTIONS/*.parquet"
fi

# XX_EXPERIMENT_ASSIGNMENTS: 8,062 rows
if want XX_EXPERIMENT_ASSIGNMENTS; then
echo "XX_EXPERIMENT_ASSIGNMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_EXPERIMENT_ASSIGNMENTS\` (
  \`EXPERIMENT_ASSIGNMENT_ID\` INT64,
  \`EXPERIMENT_KEY\` STRING,
  \`ESTIMAND\` STRING,
  \`UNIT_GRAIN\` STRING,
  \`BLOCK_GRAIN\` STRING,
  \`BLOCK_KEY\` STRING,
  \`ASSIGNED_AT\` DATETIME,
  \`WINDOW_START\` DATETIME,
  \`WINDOW_END\` DATETIME,
  \`ARM\` STRING,
  \`ARM_PROBABILITY\` FLOAT64,
  \`POLICY_VERSION\` STRING,
  \`UNITS_ASSIGNED\` INT64,
  \`UNITS_ELIGIBLE\` INT64,
  \`UNIT_TABLE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_EXPERIMENT_ASSIGNMENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_EXPERIMENT_ASSIGNMENTS" "$RELEASE_URI/data/XX_EXPERIMENT_ASSIGNMENTS/*.parquet"
fi

# XX_FRAUD_WARNINGS: 24,037 rows
if want XX_FRAUD_WARNINGS; then
echo "XX_FRAUD_WARNINGS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_FRAUD_WARNINGS\` (
  \`FRAUD_WARNING_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`PAYMENT_INSTRUMENT_ID\` INT64,
  \`REPORTED_DATE\` DATETIME,
  \`RECEIVED_DATE\` DATETIME,
  \`AMOUNT\` FLOAT64,
  \`FRAUD_TYPE_CODE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_FRAUD_WARNINGS.json" "$BQ_PROJECT:$BQ_DATASET.XX_FRAUD_WARNINGS" "$RELEASE_URI/data/XX_FRAUD_WARNINGS/*.parquet"
fi

# XX_GL_INTERFACE_HIST: 492,089,977 rows
if want XX_GL_INTERFACE_HIST; then
echo "XX_GL_INTERFACE_HIST"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_GL_INTERFACE_HIST\` (
  \`INTERFACE_LINE_ID\` INT64,
  \`JE_HEADER_ID\` INT64,
  \`JE_LINE_NUM\` INT64,
  \`ACCOUNTING_DATE\` DATE,
  \`CODE_COMBINATION_ID\` INT64,
  \`ENTERED_DR\` FLOAT64,
  \`ENTERED_CR\` FLOAT64,
  \`STATUS\` STRING,
  \`DATE_CREATED\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`DATE_CREATED\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_GL_INTERFACE_HIST.json" "$BQ_PROJECT:$BQ_DATASET.XX_GL_INTERFACE_HIST" "$RELEASE_URI/data/XX_GL_INTERFACE_HIST/*.parquet"
fi

# XX_HOTSPOT_SNAPSHOTS: 109,009 rows
if want XX_HOTSPOT_SNAPSHOTS; then
echo "XX_HOTSPOT_SNAPSHOTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_HOTSPOT_SNAPSHOTS\` (
  \`SNAPSHOT_ID\` INT64,
  \`PUBLISHED_AT\` DATETIME,
  \`EXPIRES_AT\` DATETIME,
  \`ZONE_ID\` INT64,
  \`LAYER\` STRING,
  \`RANK\` INT64,
  \`INTENSITY\` FLOAT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_HOTSPOT_SNAPSHOTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_HOTSPOT_SNAPSHOTS" "$RELEASE_URI/data/XX_HOTSPOT_SNAPSHOTS/*.parquet"
fi

# XX_INCENTIVE_COMMITMENTS: 51,985,486 rows
if want XX_INCENTIVE_COMMITMENTS; then
echo "XX_INCENTIVE_COMMITMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_INCENTIVE_COMMITMENTS\` (
  \`COMMITMENT_ID\` INT64,
  \`OWNER_CODE\` STRING,
  \`INSTRUMENT_CODE\` STRING,
  \`REFERENCE_ID\` INT64,
  \`PARTY_TYPE\` STRING,
  \`PARTY_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`RESERVED_DATE\` DATETIME,
  \`RESERVED_AMOUNT\` FLOAT64,
  \`ACCRUED_DATE\` DATETIME,
  \`ACCRUED_AMOUNT\` FLOAT64,
  \`RELEASED_DATE\` DATETIME,
  \`RELEASED_AMOUNT\` FLOAT64,
  \`SETTLED_DATE\` DATETIME,
  \`SETTLED_AMOUNT\` FLOAT64,
  \`DISPOSITION_CODE\` STRING,
  \`POLICY_VERSION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_INCENTIVE_COMMITMENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_INCENTIVE_COMMITMENTS" "$RELEASE_URI/data/XX_INCENTIVE_COMMITMENTS/*.parquet"
fi

# XX_INGESTION_RUNS: 16,720 rows
if want XX_INGESTION_RUNS; then
echo "XX_INGESTION_RUNS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_INGESTION_RUNS\` (
  \`RUN_ID\` INT64,
  \`INTERFACE_NAME\` STRING,
  \`TARGET_TABLE\` STRING,
  \`BUSINESS_DATE\` DATE,
  \`SCHEDULED_START_DATE\` DATETIME,
  \`ACTUAL_START_DATE\` DATETIME,
  \`STATUS_CODE\` STRING,
  \`ROWS_LOADED\` INT64,
  \`ROWS_REJECTED\` INT64,
  \`LAG_DAYS\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_INGESTION_RUNS.json" "$BQ_PROJECT:$BQ_DATASET.XX_INGESTION_RUNS" "$RELEASE_URI/data/XX_INGESTION_RUNS/*.parquet"
fi

# XX_INTEGRATION_INCIDENTS: 23,873 rows
if want XX_INTEGRATION_INCIDENTS; then
echo "XX_INTEGRATION_INCIDENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_INTEGRATION_INCIDENTS\` (
  \`INCIDENT_ID\` INT64,
  \`SCOPE_CODE\` STRING,
  \`POS_VENDOR_NAME\` STRING,
  \`VENDOR_ID\` INT64,
  \`DETECTED_DATE\` DATETIME,
  \`RESOLVED_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_INTEGRATION_INCIDENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_INTEGRATION_INCIDENTS" "$RELEASE_URI/data/XX_INTEGRATION_INCIDENTS/*.parquet"
fi

# XX_INTERFACE_ERRORS: 2,237 rows
if want XX_INTERFACE_ERRORS; then
echo "XX_INTERFACE_ERRORS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_INTERFACE_ERRORS\` (
  \`INTERFACE_ERROR_ID\` INT64,
  \`INTERFACE_NAME\` STRING,
  \`SOURCE_TABLE\` STRING,
  \`SOURCE_REFERENCE\` STRING,
  \`ERROR_CODE\` STRING,
  \`ERROR_MESSAGE\` STRING,
  \`OCCURRED_DATE\` DATE,
  \`RETRY_COUNT\` INT64,
  \`STATUS_CODE\` STRING,
  \`REPAIRED_DATE\` DATE,
  \`REPAIRED_BY\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_INTERFACE_ERRORS.json" "$BQ_PROJECT:$BQ_DATASET.XX_INTERFACE_ERRORS" "$RELEASE_URI/data/XX_INTERFACE_ERRORS/*.parquet"
fi

# XX_IP_ADDRESSES: 2,665,687 rows
if want XX_IP_ADDRESSES; then
echo "XX_IP_ADDRESSES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_IP_ADDRESSES\` (
  \`IP_ADDRESS_ID\` INT64,
  \`IP_TEXT\` STRING,
  \`ASN\` INT64,
  \`ASN_NAME\` STRING,
  \`CONNECTION_TYPE_CODE\` STRING,
  \`VPN_FLAG\` STRING,
  \`COUNTRY_CODE\` STRING,
  \`CITY\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_IP_ADDRESSES.json" "$BQ_PROJECT:$BQ_DATASET.XX_IP_ADDRESSES" "$RELEASE_URI/data/XX_IP_ADDRESSES/*.parquet"
fi

# XX_LOGIN_ATTEMPTS: 33,214,593 rows
if want XX_LOGIN_ATTEMPTS; then
echo "XX_LOGIN_ATTEMPTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_LOGIN_ATTEMPTS\` (
  \`LOGIN_ATTEMPT_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`DEVICE_ID\` INT64,
  \`IP_ADDRESS_ID\` INT64,
  \`ATTEMPT_DATE\` DATETIME,
  \`OUTCOME_CODE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_LOGIN_ATTEMPTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_LOGIN_ATTEMPTS" "$RELEASE_URI/data/XX_LOGIN_ATTEMPTS/*.parquet"
fi

# XX_MARKETPLACE_ESTIMATES: 2,605,900 rows
if want XX_MARKETPLACE_ESTIMATES; then
echo "XX_MARKETPLACE_ESTIMATES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MARKETPLACE_ESTIMATES\` (
  \`ESTIMATE_ID\` INT64,
  \`LAYER_CODE\` STRING,
  \`ZONE_ID\` INT64,
  \`BOROUGH_ID\` INT64,
  \`WINDOW_START\` DATETIME,
  \`WINDOW_END\` DATETIME,
  \`ISSUED_AT\` DATETIME,
  \`AVAILABLE_AT\` DATETIME,
  \`VALID_UNTIL\` DATETIME,
  \`POLICY_VERSION\` STRING,
  \`ESTIMATE_VALUE\` FLOAT64,
  \`UNIT_CODE\` STRING,
  \`SOURCE_REF\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MARKETPLACE_ESTIMATES.json" "$BQ_PROJECT:$BQ_DATASET.XX_MARKETPLACE_ESTIMATES" "$RELEASE_URI/data/XX_MARKETPLACE_ESTIMATES/*.parquet"
fi

# XX_MEMBERSHIP_EVENTS: 21,178,841 rows
if want XX_MEMBERSHIP_EVENTS; then
echo "XX_MEMBERSHIP_EVENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MEMBERSHIP_EVENTS\` (
  \`MEMBERSHIP_EVENT_ID\` INT64,
  \`CONTRACT_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`OCCURRED_AT\` DATETIME,
  \`EVENT_KIND\` STRING,
  \`CHANNEL_CODE\` STRING,
  \`AMOUNT\` FLOAT64,
  \`OFFER_CODE\` STRING,
  \`EXPERIMENT_ARM\` STRING,
  \`POLICY_VERSION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MEMBERSHIP_EVENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MEMBERSHIP_EVENTS" "$RELEASE_URI/data/XX_MEMBERSHIP_EVENTS/*.parquet"
fi

# XX_MEMBERSHIP_ORDER_BENEFITS: 44,815,297 rows
if want XX_MEMBERSHIP_ORDER_BENEFITS; then
echo "XX_MEMBERSHIP_ORDER_BENEFITS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MEMBERSHIP_ORDER_BENEFITS\` (
  \`HEADER_ID\` INT64,
  \`CONTRACT_ID\` INT64,
  \`ELIGIBLE_FLAG\` STRING,
  \`INELIGIBLE_REASON\` STRING,
  \`LIST_DELIVERY_FEE\` FLOAT64,
  \`LIST_SERVICE_FEE\` FLOAT64,
  \`DELIVERY_FEE_WAIVED\` FLOAT64,
  \`SERVICE_FEE_REDUCED\` FLOAT64,
  \`PICKUP_CREDIT\` FLOAT64,
  \`FEE_ALLOCATED\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MEMBERSHIP_ORDER_BENEFITS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MEMBERSHIP_ORDER_BENEFITS" "$RELEASE_URI/data/XX_MEMBERSHIP_ORDER_BENEFITS/*.parquet"
fi

# XX_MERCHANT_CLOSURES: 367,997 rows
if want XX_MERCHANT_CLOSURES; then
echo "XX_MERCHANT_CLOSURES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MERCHANT_CLOSURES\` (
  \`CLOSURE_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`CLOSURE_TYPE_CODE\` STRING,
  \`STARTED_DATE\` DATE,
  \`ENDED_DATE\` DATE,
  \`CLOSED_DAYS\` INT64,
  \`REPORTED_BY_CODE\` STRING,
  \`REOPENED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MERCHANT_CLOSURES.json" "$BQ_PROJECT:$BQ_DATASET.XX_MERCHANT_CLOSURES" "$RELEASE_URI/data/XX_MERCHANT_CLOSURES/*.parquet"
fi

# XX_MERCHANT_HANDOFF_CONFIRMATIONS: 27,909,875 rows
if want XX_MERCHANT_HANDOFF_CONFIRMATIONS; then
echo "XX_MERCHANT_HANDOFF_CONFIRMATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MERCHANT_HANDOFF_CONFIRMATIONS\` (
  \`CONFIRMATION_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`MERCHANT_VENDOR_ID\` INT64,
  \`CONFIRMED_AT\` DATETIME,
  \`CONFIRMED_VENDOR_ID\` INT64,
  \`METHOD\` STRING
)
PARTITION BY DATETIME_TRUNC(\`CONFIRMED_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MERCHANT_HANDOFF_CONFIRMATIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MERCHANT_HANDOFF_CONFIRMATIONS" "$RELEASE_URI/data/XX_MERCHANT_HANDOFF_CONFIRMATIONS/*.parquet"
fi

# XX_MERCHANT_HOLIDAY_HOURS: 87,710 rows
if want XX_MERCHANT_HOLIDAY_HOURS; then
echo "XX_MERCHANT_HOLIDAY_HOURS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MERCHANT_HOLIDAY_HOURS\` (
  \`MERCHANT_HOLIDAY_HOURS_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`SERVICE_DATE\` DATE,
  \`HOLIDAY_CODE\` STRING,
  \`CLOSED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MERCHANT_HOLIDAY_HOURS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MERCHANT_HOLIDAY_HOURS" "$RELEASE_URI/data/XX_MERCHANT_HOLIDAY_HOURS/*.parquet"
fi

# XX_MERCHANT_HOURS: 125,314 rows
if want XX_MERCHANT_HOURS; then
echo "XX_MERCHANT_HOURS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MERCHANT_HOURS\` (
  \`MERCHANT_HOURS_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`DAY_OF_WEEK\` INT64,
  \`OPENS_MINUTE\` INT64,
  \`CLOSES_MINUTE\` INT64,
  \`CLOSED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MERCHANT_HOURS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MERCHANT_HOURS" "$RELEASE_URI/data/XX_MERCHANT_HOURS/*.parquet"
fi

# XX_MERCHANT_INTEGRATIONS: 17,902 rows
if want XX_MERCHANT_INTEGRATIONS; then
echo "XX_MERCHANT_INTEGRATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MERCHANT_INTEGRATIONS\` (
  \`INTEGRATION_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`CHANNEL_CODE\` STRING,
  \`POS_VENDOR_NAME\` STRING,
  \`AUTO_ACCEPT_FLAG\` STRING,
  \`MENU_SYNC_MODE_CODE\` STRING,
  \`PREP_TIME_SOURCE_CODE\` STRING,
  \`ORDER_INJECTION_LAG_SECONDS\` INT64,
  \`DEFAULT_PREP_MINUTES\` INT64,
  \`BUSY_KITCHEN_FLAG\` STRING,
  \`AUTO_RELEASE_FLAG\` STRING,
  \`READY_SIGNAL_FLAG\` STRING,
  \`ACTIVATED_DATE\` DATE,
  \`DEACTIVATED_DATE\` DATE,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MERCHANT_INTEGRATIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MERCHANT_INTEGRATIONS" "$RELEASE_URI/data/XX_MERCHANT_INTEGRATIONS/*.parquet"
fi

# XX_MERCHANT_OPS_ACTIONS: 3,444 rows
if want XX_MERCHANT_OPS_ACTIONS; then
echo "XX_MERCHANT_OPS_ACTIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MERCHANT_OPS_ACTIONS\` (
  \`ACTION_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`ZONE_ID\` INT64,
  \`DECIDED_DATE\` DATETIME,
  \`REPORT_WINDOW_START\` DATETIME,
  \`REPORT_WINDOW_END\` DATETIME,
  \`EFFECTIVE_FROM\` DATETIME,
  \`EFFECTIVE_TO\` DATETIME,
  \`ACTION_KIND_CODE\` STRING,
  \`REFUSALS_READ\` INT64,
  \`ADMITTED_READ\` INT64,
  \`OVERTIME_MINUTES_READ\` FLOAT64,
  \`WAIT_SECONDS_READ\` FLOAT64,
  \`THRESHOLD_TICKETS\` INT64,
  \`THRESHOLD_OVERTIME_MINUTES\` FLOAT64,
  \`STATUS_CODE\` STRING,
  \`POLICY_VERSION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MERCHANT_OPS_ACTIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MERCHANT_OPS_ACTIONS" "$RELEASE_URI/data/XX_MERCHANT_OPS_ACTIONS/*.parquet"
fi

# XX_MERCHANT_RATING_SNAPSHOTS: 5,072,584 rows
if want XX_MERCHANT_RATING_SNAPSHOTS; then
echo "XX_MERCHANT_RATING_SNAPSHOTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MERCHANT_RATING_SNAPSHOTS\` (
  \`RATING_SNAPSHOT_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`AS_OF_DATE\` DATE,
  \`DISPLAYED_RATING\` FLOAT64,
  \`RATING_COUNT\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MERCHANT_RATING_SNAPSHOTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MERCHANT_RATING_SNAPSHOTS" "$RELEASE_URI/data/XX_MERCHANT_RATING_SNAPSHOTS/*.parquet"
fi

# XX_MERCHANT_READY_REPORTS: 79,167,242 rows
if want XX_MERCHANT_READY_REPORTS; then
echo "XX_MERCHANT_READY_REPORTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MERCHANT_READY_REPORTS\` (
  \`READY_REPORT_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`MERCHANT_VENDOR_ID\` INT64,
  \`REPORTED_AT\` DATETIME,
  \`REPORTED_BY_CODE\` STRING,
  \`RECEIVED_AT\` DATETIME,
  \`DELIVERY_CODE\` STRING,
  \`INCIDENT_ID\` INT64,
  \`PRV_READY_REPORT_ID\` INT64,
  \`FIRST_POSTED_RECORD_FLAG\` STRING,
  \`CURRENT_RECORD_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MERCHANT_READY_REPORTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MERCHANT_READY_REPORTS" "$RELEASE_URI/data/XX_MERCHANT_READY_REPORTS/*.parquet"
fi

# XX_MERCHANT_REGULATORY_EVENTS: 12,273 rows
if want XX_MERCHANT_REGULATORY_EVENTS; then
echo "XX_MERCHANT_REGULATORY_EVENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_MERCHANT_REGULATORY_EVENTS\` (
  \`REGULATORY_EVENT_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`EVENT_DATE\` DATE,
  \`EVENT_TYPE\` STRING,
  \`GRADE_CODE\` STRING,
  \`INSPECTION_SCORE\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_MERCHANT_REGULATORY_EVENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_MERCHANT_REGULATORY_EVENTS" "$RELEASE_URI/data/XX_MERCHANT_REGULATORY_EVENTS/*.parquet"
fi

# XX_ORDER_PREP_QUOTES: 80,908,384 rows
if want XX_ORDER_PREP_QUOTES; then
echo "XX_ORDER_PREP_QUOTES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_ORDER_PREP_QUOTES\` (
  \`QUOTE_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`QUOTED_AT\` DATETIME,
  \`QUOTED_PREP_MINUTES\` FLOAT64,
  \`QUOTE_SOURCE_CODE\` STRING,
  \`QUOTED_READY_AT\` DATETIME,
  \`POLICY_VERSION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_ORDER_PREP_QUOTES.json" "$BQ_PROJECT:$BQ_DATASET.XX_ORDER_PREP_QUOTES" "$RELEASE_URI/data/XX_ORDER_PREP_QUOTES/*.parquet"
fi

# XX_ORDER_PROMISES: 71,535,421 rows
if want XX_ORDER_PROMISES; then
echo "XX_ORDER_PROMISES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_ORDER_PROMISES\` (
  \`HEADER_ID\` INT64,
  \`QUOTED_AT\` DATETIME,
  \`PROMISED_DELIVERY_AT\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`QUOTED_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_ORDER_PROMISES.json" "$BQ_PROJECT:$BQ_DATASET.XX_ORDER_PROMISES" "$RELEASE_URI/data/XX_ORDER_PROMISES/*.parquet"
fi

# XX_ORDER_REJECTIONS: 427,040 rows
if want XX_ORDER_REJECTIONS; then
echo "XX_ORDER_REJECTIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_ORDER_REJECTIONS\` (
  \`REJECTION_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`REJECTED_DATE\` DATETIME,
  \`REJECT_STAGE_CODE\` STRING,
  \`REASON_CODE\` STRING,
  \`AUTO_REJECT_FLAG\` STRING,
  \`MINUTES_TO_REJECT\` FLOAT64,
  \`REPLACEMENT_HEADER_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_ORDER_REJECTIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_ORDER_REJECTIONS" "$RELEASE_URI/data/XX_ORDER_REJECTIONS/*.parquet"
fi

# XX_ORDER_STATUS_HIST: 482,054,407 rows
if want XX_ORDER_STATUS_HIST; then
echo "XX_ORDER_STATUS_HIST"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_ORDER_STATUS_HIST\` (
  \`STATUS_HIST_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`STATUS_CODE\` STRING,
  \`STATUS_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_ORDER_STATUS_HIST.json" "$BQ_PROJECT:$BQ_DATASET.XX_ORDER_STATUS_HIST" "$RELEASE_URI/data/XX_ORDER_STATUS_HIST/*.parquet"
fi

# XX_PAYMENT_AUTHS: 86,015,831 rows
if want XX_PAYMENT_AUTHS; then
echo "XX_PAYMENT_AUTHS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PAYMENT_AUTHS\` (
  \`AUTH_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`PAYMENT_INSTRUMENT_ID\` INT64,
  \`AUTH_DATE\` DATETIME,
  \`AMOUNT\` FLOAT64,
  \`STATUS_CODE\` STRING,
  \`AUTH_CODE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PAYMENT_AUTHS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PAYMENT_AUTHS" "$RELEASE_URI/data/XX_PAYMENT_AUTHS/*.parquet"
fi

# XX_PAYMENT_INSTRUMENTS: 7,357,570 rows
if want XX_PAYMENT_INSTRUMENTS; then
echo "XX_PAYMENT_INSTRUMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PAYMENT_INSTRUMENTS\` (
  \`PAYMENT_INSTRUMENT_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`INSTRUMENT_TYPE_CODE\` STRING,
  \`CARD_BIN\` INT64,
  \`CARD_FINGERPRINT_ID\` INT64,
  \`MASKED_NUMBER\` STRING,
  \`ADDED_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PAYMENT_INSTRUMENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PAYMENT_INSTRUMENTS" "$RELEASE_URI/data/XX_PAYMENT_INSTRUMENTS/*.parquet"
fi

# XX_PAYOUT_PERIODS: 499 rows
if want XX_PAYOUT_PERIODS; then
echo "XX_PAYOUT_PERIODS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PAYOUT_PERIODS\` (
  \`PAYOUT_PERIOD_ID\` INT64,
  \`PARTY_TYPE_CODE\` STRING,
  \`CADENCE_DAYS\` INT64,
  \`PERIOD_START_DATE\` DATE,
  \`PERIOD_END_DATE\` DATE,
  \`PAYOUT_DATE\` DATETIME,
  \`HOLIDAY_SHIFTED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PAYOUT_PERIODS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PAYOUT_PERIODS" "$RELEASE_URI/data/XX_PAYOUT_PERIODS/*.parquet"
fi

# XX_PAY_PERIOD_INCENTIVES: 53 rows
if want XX_PAY_PERIOD_INCENTIVES; then
echo "XX_PAY_PERIOD_INCENTIVES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PAY_PERIOD_INCENTIVES\` (
  \`PAY_PERIOD_INCENTIVE_ID\` INT64,
  \`PAYOUT_PERIOD_ID\` INT64,
  \`PERIOD_START_DATE\` DATE,
  \`PERIOD_END_DATE\` DATE,
  \`RATE_PER_HOUR\` FLOAT64,
  \`ENFORCEMENT_STATUS_CODE\` STRING,
  \`ENGINE_CODE\` STRING,
  \`COURIER_COUNT\` INT64,
  \`CONNECTED_HOURS\` FLOAT64,
  \`TRIP_HOURS\` FLOAT64,
  \`COUNTABLE_PAY_AMOUNT\` FLOAT64,
  \`TOPUP_INDIVIDUAL_AMOUNT\` FLOAT64,
  \`TOPUP_AGGREGATE_AMOUNT\` FLOAT64,
  \`QUEST_AMOUNT\` FLOAT64,
  \`SURGE_AMOUNT\` FLOAT64,
  \`ABSORBED_JOINT_AMOUNT\` FLOAT64,
  \`ABSORBED_QUEST_PRORATA_AMOUNT\` FLOAT64,
  \`ABSORBED_SURGE_PRORATA_AMOUNT\` FLOAT64,
  \`ABSORBED_QUEST_ALONE_AMOUNT\` FLOAT64,
  \`ABSORBED_SURGE_ALONE_AMOUNT\` FLOAT64,
  \`REPORT_SHARE\` FLOAT64,
  \`FINAL_SHARE\` FLOAT64,
  \`SIZED_AT\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PAY_PERIOD_INCENTIVES.json" "$BQ_PROJECT:$BQ_DATASET.XX_PAY_PERIOD_INCENTIVES" "$RELEASE_URI/data/XX_PAY_PERIOD_INCENTIVES/*.parquet"
fi

# XX_PREP_ESTIMATE_LOG: 36,588,947 rows
if want XX_PREP_ESTIMATE_LOG; then
echo "XX_PREP_ESTIMATE_LOG"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PREP_ESTIMATE_LOG\` (
  \`UPDATE_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`APPLIED_DATE\` DATETIME,
  \`SOURCE_CODE\` STRING,
  \`INPUT_MINUTES\` FLOAT64,
  \`ESTIMATE_BEFORE\` FLOAT64,
  \`ESTIMATE_AFTER\` FLOAT64,
  \`POLICY_VERSION\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PREP_ESTIMATE_LOG.json" "$BQ_PROJECT:$BQ_DATASET.XX_PREP_ESTIMATE_LOG" "$RELEASE_URI/data/XX_PREP_ESTIMATE_LOG/*.parquet"
fi

# XX_PROMOTION_ALLOCATIONS: 34,097,654 rows
if want XX_PROMOTION_ALLOCATIONS; then
echo "XX_PROMOTION_ALLOCATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PROMOTION_ALLOCATIONS\` (
  \`ALLOCATION_ID\` INT64,
  \`DECISION_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`ASSIGNED_AT\` DATETIME,
  \`WINDOW_END\` DATETIME,
  \`ARM\` STRING,
  \`SEND_PROBABILITY\` FLOAT64,
  \`VARIANT_ID\` INT64,
  \`ARM_PROBABILITY\` FLOAT64,
  \`PRIOR_ORDERS\` INT64,
  \`PRIOR_PUSHES_7D\` INT64,
  \`LAST_PURCHASE_AT\` DATETIME,
  \`PRIOR_EXPOSURES_CAMPAIGN\` INT64,
  \`DAYS_SINCE_LAST_EXPOSURE\` FLOAT64,
  \`ELIGIBILITY\` STRING,
  \`PRIOR_ASSIGNMENTS_7D\` INT64,
  \`BLOCK_KEY\` STRING
)
PARTITION BY DATETIME_TRUNC(\`ASSIGNED_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PROMOTION_ALLOCATIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PROMOTION_ALLOCATIONS" "$RELEASE_URI/data/XX_PROMOTION_ALLOCATIONS/*.parquet"
fi

# XX_PROMOTION_CHECKOUTS: 99,173,355 rows
if want XX_PROMOTION_CHECKOUTS; then
echo "XX_PROMOTION_CHECKOUTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PROMOTION_CHECKOUTS\` (
  \`CHECKOUT_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`STARTED_AT\` DATETIME,
  \`HEADER_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`CONTACT_ID\` INT64,
  \`VARIANT_ID\` INT64,
  \`QUOTED_SUBTOTAL\` FLOAT64,
  \`QUOTED_DISCOUNT\` FLOAT64,
  \`OUTCOME\` STRING
)
PARTITION BY DATETIME_TRUNC(\`STARTED_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PROMOTION_CHECKOUTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PROMOTION_CHECKOUTS" "$RELEASE_URI/data/XX_PROMOTION_CHECKOUTS/*.parquet"
fi

# XX_PROMOTION_CONTACTS: 30,685,899 rows
if want XX_PROMOTION_CONTACTS; then
echo "XX_PROMOTION_CONTACTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PROMOTION_CONTACTS\` (
  \`CONTACT_ID\` INT64,
  \`DECISION_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`SENT_AT\` DATETIME,
  \`DELIVERED_AT\` DATETIME,
  \`OPENED_AT\` DATETIME,
  \`EXPIRES_AT\` DATETIME,
  \`CHANNEL\` STRING,
  \`ALLOCATION_ID\` INT64,
  \`VARIANT_ID\` INT64,
  \`ASSIGNED_DISCOUNT_USD\` FLOAT64
)
PARTITION BY DATETIME_TRUNC(\`SENT_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PROMOTION_CONTACTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PROMOTION_CONTACTS" "$RELEASE_URI/data/XX_PROMOTION_CONTACTS/*.parquet"
fi

# XX_PROMOTION_DECISIONS: 13,530 rows
if want XX_PROMOTION_DECISIONS; then
echo "XX_PROMOTION_DECISIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PROMOTION_DECISIONS\` (
  \`DECISION_ID\` INT64,
  \`DECIDED_AT\` DATETIME,
  \`WINDOW_END\` DATETIME,
  \`BOROUGH_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`POLICY\` STRING,
  \`REASON\` STRING,
  \`STATUS\` STRING,
  \`ASSIGNMENT_PROBABILITY\` FLOAT64,
  \`EXPECTED_ORDERS\` FLOAT64,
  \`FORECAST_CAPACITY\` FLOAT64,
  \`BOOKED_ORDERS_TODAY\` INT64,
  \`TARGET_ORDERS_TODAY\` FLOAT64,
  \`WEATHER_SIGNAL\` STRING,
  \`CONTACT_LIMIT\` INT64,
  \`BUDGET_AVAILABLE_USD\` FLOAT64,
  \`COMMITTED_ORDERS\` FLOAT64,
  \`COMMITTED_COURIER_HOURS\` FLOAT64,
  \`POLICY_VERSION\` STRING,
  \`BLOCK_KEY\` STRING,
  \`KITCHEN_WARNING_READ\` FLOAT64,
  \`KITCHEN_WARNING_CHANNEL\` STRING
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PROMOTION_DECISIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PROMOTION_DECISIONS" "$RELEASE_URI/data/XX_PROMOTION_DECISIONS/*.parquet"
fi

# XX_PROMOTION_SUBMISSIONS: 42,666,911 rows
if want XX_PROMOTION_SUBMISSIONS; then
echo "XX_PROMOTION_SUBMISSIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PROMOTION_SUBMISSIONS\` (
  \`SUBMISSION_ID\` INT64,
  \`CHECKOUT_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`SUBMITTED_AT\` DATETIME,
  \`CHANNEL\` STRING,
  \`ELIGIBILITY_RESULT\` STRING,
  \`QUOTED_DISCOUNT\` FLOAT64
)
PARTITION BY DATETIME_TRUNC(\`SUBMITTED_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PROMOTION_SUBMISSIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PROMOTION_SUBMISSIONS" "$RELEASE_URI/data/XX_PROMOTION_SUBMISSIONS/*.parquet"
fi

# XX_PROMOTION_VARIANTS: 223 rows
if want XX_PROMOTION_VARIANTS; then
echo "XX_PROMOTION_VARIANTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PROMOTION_VARIANTS\` (
  \`VARIANT_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`LIST_LINE_ID\` INT64,
  \`VARIANT_NUMBER\` INT64,
  \`ASSIGNMENT_WEIGHT\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PROMOTION_VARIANTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PROMOTION_VARIANTS" "$RELEASE_URI/data/XX_PROMOTION_VARIANTS/*.parquet"
fi

# XX_PROMO_ATTEMPTS: 35,040,794 rows
if want XX_PROMO_ATTEMPTS; then
echo "XX_PROMO_ATTEMPTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PROMO_ATTEMPTS\` (
  \`PROMO_ATTEMPT_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`PROMO_CODE_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`SESSION_ID\` INT64,
  \`PROMO_CODE_ENTERED\` STRING,
  \`ATTRIBUTION_CHANNEL\` STRING,
  \`OUTCOME_CODE\` STRING,
  \`DISCOUNT_AMOUNT\` FLOAT64,
  \`ATTEMPT_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PROMO_ATTEMPTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_PROMO_ATTEMPTS" "$RELEASE_URI/data/XX_PROMO_ATTEMPTS/*.parquet"
fi

# XX_PROMO_CODES: 34,106 rows
if want XX_PROMO_CODES; then
echo "XX_PROMO_CODES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_PROMO_CODES\` (
  \`PROMO_CODE_ID\` INT64,
  \`LIST_HEADER_ID\` INT64,
  \`PROMO_CODE\` STRING,
  \`MAX_REDEMPTIONS\` INT64,
  \`PER_CUSTOMER_LIMIT\` INT64,
  \`PER_CUSTOMER_PERIOD_DAYS\` INT64,
  \`MULTI_ORDER_N\` INT64,
  \`PER_ORDER_CAP_AMOUNT\` FLOAT64,
  \`TOTAL_CAP_AMOUNT\` FLOAT64,
  \`ACTIVE_FROM\` DATETIME,
  \`ACTIVE_UNTIL\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_PROMO_CODES.json" "$BQ_PROJECT:$BQ_DATASET.XX_PROMO_CODES" "$RELEASE_URI/data/XX_PROMO_CODES/*.parquet"
fi

# XX_QUEST_INVITATIONS: 15,762,145 rows
if want XX_QUEST_INVITATIONS; then
echo "XX_QUEST_INVITATIONS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_QUEST_INVITATIONS\` (
  \`QUEST_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`OFFERED_AT\` DATETIME,
  \`RESPONDED_AT\` DATETIME,
  \`ACCEPTED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_QUEST_INVITATIONS.json" "$BQ_PROJECT:$BQ_DATASET.XX_QUEST_INVITATIONS" "$RELEASE_URI/data/XX_QUEST_INVITATIONS/*.parquet"
fi

# XX_QUEST_PROGRESS: 5,211,466 rows
if want XX_QUEST_PROGRESS; then
echo "XX_QUEST_PROGRESS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_QUEST_PROGRESS\` (
  \`QUEST_PROGRESS_ID\` INT64,
  \`QUEST_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`DELIVERIES_COMPLETED\` INT64,
  \`ACHIEVED_FLAG\` STRING,
  \`ACHIEVED_DATE\` DATETIME,
  \`BONUS_PAID_AMOUNT\` FLOAT64,
  \`PAYOUT_PERIOD_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_QUEST_PROGRESS.json" "$BQ_PROJECT:$BQ_DATASET.XX_QUEST_PROGRESS" "$RELEASE_URI/data/XX_QUEST_PROGRESS/*.parquet"
fi

# XX_QUEST_WINDOWS: 145,600 rows
if want XX_QUEST_WINDOWS; then
echo "XX_QUEST_WINDOWS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_QUEST_WINDOWS\` (
  \`QUEST_ID\` INT64,
  \`FORECAST_ID\` INT64,
  \`ZONE_ID\` INT64,
  \`OFFERED_AT\` DATETIME,
  \`QUALIFICATION_SCOPE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_QUEST_WINDOWS.json" "$BQ_PROJECT:$BQ_DATASET.XX_QUEST_WINDOWS" "$RELEASE_URI/data/XX_QUEST_WINDOWS/*.parquet"
fi

# XX_REFERRALS: 508,522 rows
if want XX_REFERRALS; then
echo "XX_REFERRALS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_REFERRALS\` (
  \`REFERRAL_ID\` INT64,
  \`REFERRER_CUST_ACCOUNT_ID\` INT64,
  \`REFEREE_CUST_ACCOUNT_ID\` INT64,
  \`REFERRED_DATE\` DATETIME,
  \`BONUS_AMOUNT\` FLOAT64,
  \`BONUS_POSTED_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_REFERRALS.json" "$BQ_PROJECT:$BQ_DATASET.XX_REFERRALS" "$RELEASE_URI/data/XX_REFERRALS/*.parquet"
fi

# XX_REFUNDS: 1,875,438 rows
if want XX_REFUNDS; then
echo "XX_REFUNDS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_REFUNDS\` (
  \`REFUND_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`REQUESTED_DATE\` DATETIME,
  \`RESOLVED_DATE\` DATETIME,
  \`AMOUNT\` FLOAT64,
  \`REASON_CODE\` STRING,
  \`CHANNEL_CODE\` STRING,
  \`PLATFORM_FUNDED_AMOUNT\` FLOAT64,
  \`MERCHANT_FUNDED_AMOUNT\` FLOAT64,
  \`CREDIT_MEMO_TRX_ID\` INT64,
  \`REFUND_RECEIPT_ID\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_REFUNDS.json" "$BQ_PROJECT:$BQ_DATASET.XX_REFUNDS" "$RELEASE_URI/data/XX_REFUNDS/*.parquet"
fi

# XX_REVIEWS: 9,521,121 rows
if want XX_REVIEWS; then
echo "XX_REVIEWS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_REVIEWS\` (
  \`REVIEW_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`REVIEW_DATE\` DATETIME,
  \`STARS\` INT64,
  \`REVIEW_TEXT_LENGTH\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_REVIEWS.json" "$BQ_PROJECT:$BQ_DATASET.XX_REVIEWS" "$RELEASE_URI/data/XX_REVIEWS/*.parquet"
fi

# XX_SUPPLY_FORECASTS: 568,764 rows
if want XX_SUPPLY_FORECASTS; then
echo "XX_SUPPLY_FORECASTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_SUPPLY_FORECASTS\` (
  \`FORECAST_ID\` INT64,
  \`ZONE_ID\` INT64,
  \`ISSUED_AT\` DATETIME,
  \`WINDOW_START\` DATETIME,
  \`WINDOW_END\` DATETIME,
  \`EXPECTED_ORDERS\` FLOAT64,
  \`PLANNED_COURIER_HOURS\` FLOAT64,
  \`EXPECTED_DELIVERIES_PER_HOUR\` FLOAT64,
  \`ACTIVITY_PERCENTILE\` FLOAT64,
  \`ELIGIBLE_FLAG\` STRING,
  \`ASSIGNMENT_PROBABILITY\` FLOAT64,
  \`LAUNCHED_FLAG\` STRING,
  \`COMMITTED_ORDERS\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_SUPPLY_FORECASTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_SUPPLY_FORECASTS" "$RELEASE_URI/data/XX_SUPPLY_FORECASTS/*.parquet"
fi

# XX_SUPPLY_SNAPSHOTS: 1,972,007 rows
if want XX_SUPPLY_SNAPSHOTS; then
echo "XX_SUPPLY_SNAPSHOTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_SUPPLY_SNAPSHOTS\` (
  \`SNAPSHOT_ID\` INT64,
  \`SNAPSHOT_AT\` DATETIME,
  \`ZONE_ID\` INT64,
  \`ONLINE_COURIERS\` INT64,
  \`IDLE_COURIERS\` INT64,
  \`BUSY_COURIERS\` INT64,
  \`WAITING_ORDERS\` INT64,
  \`SURGE_MULTIPLIER\` FLOAT64
)
PARTITION BY DATETIME_TRUNC(\`SNAPSHOT_AT\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_SUPPLY_SNAPSHOTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_SUPPLY_SNAPSHOTS" "$RELEASE_URI/data/XX_SUPPLY_SNAPSHOTS/*.parquet"
fi

# XX_SUPPORT_CASES: 7,365,600 rows
if want XX_SUPPORT_CASES; then
echo "XX_SUPPORT_CASES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_SUPPORT_CASES\` (
  \`CASE_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`CUST_ACCOUNT_ID\` INT64,
  \`VENDOR_ID\` INT64,
  \`OPENED_DATE\` DATETIME,
  \`CLOSED_DATE\` DATETIME,
  \`CHANNEL_CODE\` STRING,
  \`CATEGORY_CODE\` STRING,
  \`RESOLUTION_CODE\` STRING,
  \`OVERRIDE_CODE\` STRING,
  \`OVERRIDE_AMOUNT\` FLOAT64,
  \`ESCALATED_FLAG\` STRING,
  \`REOPENED_FLAG\` STRING,
  \`HANDLED_BY\` INT64,
  \`APPROVED_BY\` INT64,
  \`QUEUE_CODE\` STRING,
  \`ASSIGNED_DATE\` DATETIME,
  \`QUEUE_DEPTH_AT_OPEN\` INT64,
  \`AGENTS_ON_SHIFT\` INT64,
  \`HANDLING_SECONDS\` INT64,
  \`PENDING_SECONDS\` INT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_SUPPORT_CASES.json" "$BQ_PROJECT:$BQ_DATASET.XX_SUPPORT_CASES" "$RELEASE_URI/data/XX_SUPPORT_CASES/*.parquet"
fi

# XX_TIP_ADJUSTMENTS: 164,010 rows
if want XX_TIP_ADJUSTMENTS; then
echo "XX_TIP_ADJUSTMENTS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.XX_TIP_ADJUSTMENTS\` (
  \`TIP_ADJUSTMENT_ID\` INT64,
  \`HEADER_ID\` INT64,
  \`ADJUSTED_DATE\` DATETIME,
  \`PREVIOUS_TIP_AMOUNT\` FLOAT64,
  \`NEW_TIP_AMOUNT\` FLOAT64,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`PROGRAM_UPDATE_DATE\` DATETIME
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/XX_TIP_ADJUSTMENTS.json" "$BQ_PROJECT:$BQ_DATASET.XX_TIP_ADJUSTMENTS" "$RELEASE_URI/data/XX_TIP_ADJUSTMENTS/*.parquet"
fi

# ZX_LINES: 79,212,056 rows
if want ZX_LINES; then
echo "ZX_LINES"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.ZX_LINES\` (
  \`TAX_LINE_ID\` INT64,
  \`INTERNAL_ORGANIZATION_ID\` INT64,
  \`APPLICATION_ID\` INT64,
  \`ENTITY_CODE\` STRING,
  \`EVENT_CLASS_CODE\` STRING,
  \`TRX_ID\` INT64,
  \`TRX_LINE_ID\` INT64,
  \`TRX_LEVEL_TYPE\` STRING,
  \`TAX_LINE_NUMBER\` INT64,
  \`TAX_REGIME_CODE\` STRING,
  \`TAX\` STRING,
  \`TAX_RATE_CODE\` STRING,
  \`TAX_JURISDICTION_CODE\` STRING,
  \`TAX_CURRENCY_CODE\` STRING,
  \`TAX_AMT\` FLOAT64,
  \`SELF_ASSESSED_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/ZX_LINES.json" "$BQ_PROJECT:$BQ_DATASET.ZX_LINES" "$RELEASE_URI/data/ZX_LINES/*.parquet"
fi

# ZX_LINES_DET_FACTORS: 79,212,056 rows
if want ZX_LINES_DET_FACTORS; then
echo "ZX_LINES_DET_FACTORS"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.ZX_LINES_DET_FACTORS\` (
  \`INTERNAL_ORGANIZATION_ID\` INT64,
  \`APPLICATION_ID\` INT64,
  \`ENTITY_CODE\` STRING,
  \`EVENT_CLASS_CODE\` STRING,
  \`EVENT_TYPE_CODE\` STRING,
  \`LINE_LEVEL_ACTION\` STRING,
  \`TRX_ID\` INT64,
  \`TRX_LINE_ID\` INT64,
  \`TRX_LEVEL_TYPE\` STRING,
  \`TRX_DATE\` DATE,
  \`LEGAL_ENTITY_ID\` INT64,
  \`TAX_EVENT_CLASS_CODE\` STRING,
  \`TAX_EVENT_TYPE_CODE\` STRING,
  \`LINE_AMT\` FLOAT64,
  \`LINE_AMT_INCLUDES_TAX_FLAG\` STRING,
  \`CREATION_DATE\` DATETIME,
  \`CREATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`RECORD_TYPE_CODE\` STRING,
  \`OBJECT_VERSION_NUMBER\` INT64
)
PARTITION BY DATETIME_TRUNC(\`CREATION_DATE\`, MONTH);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/ZX_LINES_DET_FACTORS.json" "$BQ_PROJECT:$BQ_DATASET.ZX_LINES_DET_FACTORS" "$RELEASE_URI/data/ZX_LINES_DET_FACTORS/*.parquet"
fi

# ZX_RATES_B: 1 rows
if want ZX_RATES_B; then
echo "ZX_RATES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.ZX_RATES_B\` (
  \`TAX_RATE_CODE\` STRING,
  \`EFFECTIVE_FROM\` DATE,
  \`TAX_REGIME_CODE\` STRING,
  \`TAX\` STRING,
  \`RATE_TYPE_CODE\` STRING,
  \`PERCENTAGE_RATE\` FLOAT64,
  \`ACTIVE_FLAG\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`TAX_RATE_ID\` INT64,
  \`CONTENT_OWNER_ID\` INT64,
  \`OBJECT_VERSION_NUMBER\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/ZX_RATES_B.json" "$BQ_PROJECT:$BQ_DATASET.ZX_RATES_B" "$RELEASE_URI/data/ZX_RATES_B/*.parquet"
fi

# ZX_RATES_TL: 1 rows
if want ZX_RATES_TL; then
echo "ZX_RATES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.ZX_RATES_TL\` (
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`TAX_RATE_NAME\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`TAX_RATE_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/ZX_RATES_TL.json" "$BQ_PROJECT:$BQ_DATASET.ZX_RATES_TL" "$RELEASE_URI/data/ZX_RATES_TL/*.parquet"
fi

# ZX_REGIMES_B: 1 rows
if want ZX_REGIMES_B; then
echo "ZX_REGIMES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.ZX_REGIMES_B\` (
  \`TAX_REGIME_CODE\` STRING,
  \`COUNTRY_CODE\` STRING,
  \`EFFECTIVE_FROM\` DATE,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`TAX_REGIME_ID\` INT64,
  \`OBJECT_VERSION_NUMBER\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/ZX_REGIMES_B.json" "$BQ_PROJECT:$BQ_DATASET.ZX_REGIMES_B" "$RELEASE_URI/data/ZX_REGIMES_B/*.parquet"
fi

# ZX_REGIMES_TL: 1 rows
if want ZX_REGIMES_TL; then
echo "ZX_REGIMES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.ZX_REGIMES_TL\` (
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`TAX_REGIME_NAME\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`TAX_REGIME_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/ZX_REGIMES_TL.json" "$BQ_PROJECT:$BQ_DATASET.ZX_REGIMES_TL" "$RELEASE_URI/data/ZX_REGIMES_TL/*.parquet"
fi

# ZX_TAXES_B: 1 rows
if want ZX_TAXES_B; then
echo "ZX_TAXES_B"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.ZX_TAXES_B\` (
  \`TAX\` STRING,
  \`EFFECTIVE_FROM\` DATE,
  \`TAX_REGIME_CODE\` STRING,
  \`TAX_TYPE_CODE\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`REQUEST_ID\` INT64,
  \`PROGRAM_APPLICATION_ID\` INT64,
  \`PROGRAM_ID\` INT64,
  \`TAX_ID\` INT64,
  \`CONTENT_OWNER_ID\` INT64,
  \`OBJECT_VERSION_NUMBER\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/ZX_TAXES_B.json" "$BQ_PROJECT:$BQ_DATASET.ZX_TAXES_B" "$RELEASE_URI/data/ZX_TAXES_B/*.parquet"
fi

# ZX_TAXES_TL: 1 rows
if want ZX_TAXES_TL; then
echo "ZX_TAXES_TL"
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" query --use_legacy_sql=false <<SQL
CREATE OR REPLACE TABLE \`${BQ_PROJECT}.${BQ_DATASET}.ZX_TAXES_TL\` (
  \`LANGUAGE\` STRING,
  \`SOURCE_LANG\` STRING,
  \`TAX_FULL_NAME\` STRING,
  \`CREATED_BY\` INT64,
  \`CREATION_DATE\` DATETIME,
  \`LAST_UPDATED_BY\` INT64,
  \`LAST_UPDATE_DATE\` DATETIME,
  \`LAST_UPDATE_LOGIN\` INT64,
  \`TAX_ID\` INT64
);
SQL
bq --project_id="$BQ_PROJECT" --location="$BQ_LOCATION" load --source_format=PARQUET --schema="$HERE/schemas/ZX_TAXES_TL.json" "$BQ_PROJECT:$BQ_DATASET.ZX_TAXES_TL" "$RELEASE_URI/data/ZX_TAXES_TL/*.parquet"
fi