Feat: Multiplayer sessions added using CRUD database.

static/PostgreSQL/10500_tbl_TCG_Change_Set.sql

@@ -0,0 +1,7 @@
+
+CREATE TABLE tcg.public.TCG_Change_Set (
+	  change_set_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , comment TEXT
+    , updated_last_on TIMESTAMP NOT NULL
+    , updated_last_by_user_id INT NOT NULL
+);

static/PostgreSQL/10504_tbl_TCG_User.sql

@@ -0,0 +1,25 @@
+
+CREATE TABLE tcg.public.TCG_User (
+      user_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , user_auth0_id VARCHAR(200)
+    , firstname TEXT
+    , surname TEXT
+    , email VARCHAR(256)
+    , is_email_verified BOOLEAN NOT NULL DEFAULT FALSE
+    , is_super_user BOOLEAN NOT NULL DEFAULT FALSE
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+    , created_on TIMESTAMP
+    , created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_User_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_User_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_Change_Set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/10505_tbl_TCG_User_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_User_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_User_Audit_user_id
+		FOREIGN KEY (user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , name_field TEXT NOT NULL
+    , value_prev TEXT
+    , value_new TEXT
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_User_Audit_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/10510_tbl_Error_Type.sql

@@ -0,0 +1,21 @@
+
+CREATE TABLE tcg.public.Error_Type (
+      error_type_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , code TEXT NOT NULL
+    , name TEXT NOT NULL
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+    , created_on TIMESTAMP
+    , created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_User_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_User_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_Change_Set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/10511_tbl_Error_Type_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.Error_Type_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , error_type_id INT NOT NULL
+    , CONSTRAINT FK_Error_Type_Audit_error_type_id
+		FOREIGN KEY (error_type_id)
+        REFERENCES tcg.public.Error_Type(error_type_id)
+    , name_field TEXT NOT NULL
+    , value_prev TEXT
+    , value_new TEXT
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_Error_Type_Audit_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/10514_tbl_Error.sql

@@ -0,0 +1,26 @@
+
+CREATE TABLE tcg.public.Error (
+      error_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , guid UUID NOT NULL
+    , error_type_id INT NOT NULL
+    , CONSTRAINT FK_Error_Type_error_type_id
+        FOREIGN KEY (error_type_id)
+        REFERENCES tcg.public.Error_Type(error_type_id)
+    , message TEXT NOT NULL
+    , display_order INT
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+    , created_on TIMESTAMP
+    , created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_User_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_User_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_Change_Set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/10515_tbl_Error_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.Error_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , error_id INT NOT NULL
+    , CONSTRAINT FK_Error_Audit_error_id
+		FOREIGN KEY (error_id)
+        REFERENCES tcg.public.Error(error_id)
+    , name_field TEXT NOT NULL
+    , value_prev TEXT
+    , value_new TEXT
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_Error_Audit_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11001_tbl_TCG_Condition.sql

@@ -0,0 +1,25 @@
+CREATE TABLE tcg.public.TCG_Condition (
+	  condition_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, name TEXT NOT NULL 
+	, code TEXT NOT NULL
+	, description TEXT NOT NULL
+	, summary TEXT NOT NULL
+	, us_name TEXT NOT NULL
+	, price_ratio_min DECIMAL(7, 1)
+	, price_ratio_max DECIMAL(7, 1)
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_Condition_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_Condition_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_Condition_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11002_tbl_TCG_Condition_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_Condition_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, condition_id INT NOT NULL
+	, CONSTRAINT FK_TCG_Condition_Audit_condition_id
+		FOREIGN KEY (condition_id)
+		REFERENCES tcg.public.TCG_Condition(condition_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_Condition_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11101_tbl_TCG_MTG_Finish.sql

@@ -0,0 +1,22 @@
+CREATE TABLE tcg.public.TCG_MTG_Finish (
+	  finish_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, name TEXT NOT NULL 
+	, description TEXT NOT NULL
+	, price_ratio_min DECIMAL(6, 1)
+	, price_ratio_max DECIMAL(6, 1)
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Finish_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Finish_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Finish_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11102_tbl_TCG_MTG_Finish_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Finish_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, finish_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Finish_Audit_finish_id
+		FOREIGN KEY (finish_id)
+		REFERENCES tcg.public.TCG_MTG_Finish(finish_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Finish_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11130_tbl_TCG_MTG_Card.sql

@@ -0,0 +1,132 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Card (
+	  card_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , all_parts TEXT
+    , arena_id INTEGER
+    , artist TEXT
+    , artist_ids TEXT
+    , booster BOOLEAN
+    , border_color TEXT
+    , card_back_id TEXT
+    , card_faces TEXT
+    , cardmarket_id INTEGER
+    , cmc DECIMAL(8, 1)
+    , collector_number TEXT
+    , color_identity TEXT
+    , colors TEXT
+    , content_warning BOOLEAN
+    , digital BOOLEAN
+    , edhrec_rank INTEGER
+    , finishes TEXT
+    , flavor_name TEXT
+    , flavor_text TEXT
+    , foil BOOLEAN
+    , frame TEXT
+    , full_art BOOLEAN
+    , game_changer BOOLEAN
+    , games TEXT
+    , hand_modifier TEXT
+    , highres_image BOOLEAN
+    , id TEXT
+    , image_status TEXT
+    , image_uri_art_crop TEXT
+    , image_uri_border_crop TEXT
+    , image_uri_large TEXT
+    , image_uri_normal TEXT
+    , image_uri_png TEXT
+    , image_uri_small TEXT
+    , keywords TEXT
+    , lang TEXT
+    , layout TEXT
+    , legal_alchemy BOOLEAN
+    , legal_brawl BOOLEAN
+    , legal_commander BOOLEAN
+    , legal_duel BOOLEAN
+    , legal_future BOOLEAN
+    , legal_gladiator BOOLEAN
+    , legal_historic BOOLEAN
+    , legal_legacy BOOLEAN
+    , legal_modern BOOLEAN
+    , legal_oathbreaker BOOLEAN
+    , legal_oldschool BOOLEAN
+    , legal_pauper BOOLEAN
+    , legal_paupercommander BOOLEAN
+    , legal_penny BOOLEAN
+    , legal_pioneer BOOLEAN
+    , legal_predh BOOLEAN
+    , legal_premodern BOOLEAN
+    , legal_standard BOOLEAN
+    , legal_standardbrawl BOOLEAN
+    , legal_timeless BOOLEAN
+    , legal_vintage BOOLEAN
+    , life_modifier TEXT
+    , loyalty TEXT
+    , mana_cost TEXT
+    , mtgo_id INTEGER
+    , multiverse_ids TEXT
+    , name TEXT NOT NULL
+    , nonfoil BOOLEAN
+    , oracle_id TEXT
+    , oracle_text TEXT
+    , oversized BOOLEAN
+    , penny_rank INTEGER
+    , power TEXT
+    , preview_date DATE
+    , preview_source TEXT
+    , preview_source_uri TEXT
+    , price_eur DECIMAL(10, 3)
+    , price_eur_foil DECIMAL(10, 3)
+    , price_tix DECIMAL(10, 3)
+    , price_usd DECIMAL(10, 3)
+    , price_usd_etched DECIMAL(10, 3)
+    , price_usd_foil DECIMAL(10, 3)
+    , printed_name TEXT
+    , printed_text TEXT
+    , printed_type_line TEXT
+    , prints_search_uri TEXT
+    , produced_mana TEXT
+    , promo BOOLEAN
+    , purchase_cardhoarder TEXT
+    , purchase_cardmarket TEXT
+    , purchase_tcgplayer TEXT
+    , rarity TEXT
+    , released_at DATE
+    , reprint BOOLEAN
+    , reserved BOOLEAN
+    , rulings_uri TEXT
+    , scryfall_set_uri TEXT
+    , scryfall_uri TEXT
+    , security_stamp TEXT
+    , set TEXT
+    , set_id TEXT
+    , set_name TEXT
+    , set_search_uri TEXT
+    , set_type TEXT
+    , set_uri TEXT
+    , story_spotlight BOOLEAN
+    , tcgplayer_id INTEGER
+    , textless BOOLEAN
+    , toughness TEXT
+    , type_line TEXT
+    , uri TEXT
+    , uri_edhrec TEXT
+    , uri_gatherer TEXT
+    , uri_tcgplayer_infinite_articles TEXT
+    , uri_tcgplayer_infinite_decks TEXT
+    , variation BOOLEAN
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Card_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Card_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Card_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11131_tbl_TCG_MTG_Card_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Card_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, card_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Card_Audit_card_id
+		FOREIGN KEY (card_id)
+		REFERENCES tcg.public.TCG_MTG_Card(card_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Card_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11150_tbl_TCG_MTG_Inventory.sql

@@ -0,0 +1,68 @@
+CREATE TABLE tcg.public.TCG_MTG_Inventory (
+	  inventory_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , card_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_card_id
+        FOREIGN KEY (card_id)
+        REFERENCES tcg.public.TCG_MTG_Card(card_id)
+    , finish_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_finish_id
+        FOREIGN KEY (finish_id)
+        REFERENCES tcg.public.TCG_MTG_Finish(finish_id)
+    , condition_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_condition_id
+        FOREIGN KEY (condition_id)
+        REFERENCES tcg.public.TCG_Condition(condition_id)
+    , sleeve_colour_name TEXT
+    , location_name TEXT
+    , acquired_from TEXT
+    , acquired_on TIMESTAMP
+    , cost_gbp DECIMAL(6, 2) NOT NULL
+    , sale_price_gbp DECIMAL(6, 2)
+    , is_sold BOOLEAN NOT NULL DEFAULT FALSE
+    , is_destroyed BOOLEAN NOT NULL DEFAULT FALSE
+    , notes TEXT
+    , alterations_customisations TEXT
+    , grading_company_name TEXT
+    , grading_score TEXT
+    , subgrades TEXT
+    , misprint_errors TEXT
+    , miscut_errors TEXT
+    , playability TEXT
+    , owner_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_owner_user_id
+        FOREIGN KEY (owner_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , ownership_status_name TEXT
+    , trading_status_name TEXT
+    , loaned_to_user_id INT
+    , CONSTRAINT FK_TCG_MTG_Inventory_loaned_to_user_id
+        FOREIGN KEY (loaned_to_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , loan_start_on TIMESTAMP
+    , loan_end_on TIMESTAMP
+    , provenance TEXT
+    , signed_by_names TEXT
+    , signature_condition_name TEXT
+    , token_rear_side_card_id INT
+    , CONSTRAINT FK_TCG_MTG_Inventory_token_rear_side_card_id
+        FOREIGN KEY (token_rear_side_card_id)
+        REFERENCES tcg.public.TCG_MTG_Card(card_id)
+    , display_order INT NOT NULL
+    , front_name TEXT NOT NULL
+    , rear_name TEXT
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11151_tbl_TCG_MTG_Inventory_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Inventory_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, inventory_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Inventory_Audit_inventory_id
+		FOREIGN KEY (inventory_id)
+		REFERENCES tcg.public.TCG_MTG_Inventory(inventory_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Inventory_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11152_tbl_TCG_MTG_Inventory_Temp.sql

@@ -0,0 +1,77 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Inventory_Temp (
+	  temp_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , inventory_id INT
+    , card_id INT
+    , CONSTRAINT FK_TCG_MTG_Inventory_Temp_card_id
+        FOREIGN KEY (card_id)
+        REFERENCES tcg.public.TCG_MTG_Card(card_id)
+    , finish_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_Temp_finish_id
+        FOREIGN KEY (finish_id)
+        REFERENCES tcg.public.TCG_MTG_Finish(finish_id)
+    , condition_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_Temp_condition_id
+        FOREIGN KEY (condition_id)
+        REFERENCES tcg.public.TCG_Condition(condition_id)
+    , sleeve_colour_name TEXT
+    , location_name TEXT
+    , acquired_from TEXT
+    , acquired_on TIMESTAMP
+    , cost_gbp DECIMAL(6, 2) NOT NULL
+    , sale_price_gbp DECIMAL(6, 2)
+    , is_sold BOOLEAN NOT NULL DEFAULT FALSE
+    , is_destroyed BOOLEAN NOT NULL DEFAULT FALSE
+    , notes TEXT
+    , alterations_customisations TEXT
+    , grading_company_name TEXT
+    , grading_score TEXT
+    , subgrades TEXT
+    , misprint_errors TEXT
+    , miscut_errors TEXT
+    , playability TEXT
+    , owner_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_Temp_owner_user_id
+        FOREIGN KEY (owner_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , ownership_status_name TEXT
+    , trading_status_name TEXT
+    , loaned_to_user_id INT
+    , CONSTRAINT FK_TCG_MTG_Inventory_Temp_loaned_to_user_id
+        FOREIGN KEY (loaned_to_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , loan_start_on TIMESTAMP
+    , loan_end_on TIMESTAMP
+    , provenance TEXT
+    , signed_by_names TEXT
+    , signature_condition_name TEXT
+    , token_rear_side_card_id INT
+    , CONSTRAINT FK_TCG_MTG_Inventory_token_rear_side_card_id
+        FOREIGN KEY (token_rear_side_card_id)
+        REFERENCES tcg.public.TCG_MTG_Card(card_id)
+    , display_order INT NOT NULL
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	-- , created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_Temp_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	-- , updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_Temp_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Inventory_Temp_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+    
+    , guid UUID NOT NULL
+    , set_code TEXT
+    , collector_number TEXT
+    , name TEXT
+    , is_token BOOLEAN
+    , token_rear_side_name TEXT
+    , token_rear_side_set_code TEXT
+    , token_rear_side_collector_number TEXT
+);

static/PostgreSQL/11196_tbl_TCG_MTG_Deck_Commander_Bracket.sql

@@ -0,0 +1,22 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Deck_Commander_Bracket (
+	  commander_bracket_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , name TEXT NOT NULL
+    , description TEXT
+    , display_order INT NOT NULL
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_Commander_Bracket_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_Commander_Bracket_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_Commander_Bracket_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11197_tbl_TCG_MTG_Deck_Commander_Bracket_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Deck_Commander_Bracket_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, commander_bracket_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Deck_Commander_Bracket_Audit_commander_bracket_id
+		FOREIGN KEY (commander_bracket_id)
+		REFERENCES tcg.public.TCG_MTG_Deck_Commander_Bracket(commander_bracket_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Deck_Commander_Bracket_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11200_tbl_TCG_MTG_Deck.sql

@@ -0,0 +1,25 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Deck (
+	  deck_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , name TEXT NOT NULL
+    , is_commander BOOLEAN NOT NULL DEFAULT TRUE
+    , commander_bracket_id INT
+    , CONSTRAINT FK_TCG_MTG_Deck_commander_bracket_id
+        FOREIGN KEY (commander_bracket_id)
+        REFERENCES tcg.public.TCG_MTG_Deck_Commander_Bracket(commander_bracket_id)
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11201_tbl_TCG_MTG_Deck_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Deck_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, deck_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Deck_Audit_deck_id
+		FOREIGN KEY (deck_id)
+		REFERENCES tcg.public.TCG_MTG_Deck(deck_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Deck_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11204_tbl_TCG_MTG_Deck_Inventory_Link.sql

@@ -0,0 +1,27 @@
+CREATE TABLE tcg.public.TCG_MTG_Deck_Inventory_Link (
+	  link_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , deck_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_Inventory_Link_deck_id
+        FOREIGN KEY (deck_id)
+        REFERENCES tcg.public.TCG_MTG_Deck(deck_id)
+    , inventory_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_Inventory_Link_inventory_id
+        FOREIGN KEY (inventory_id)
+        REFERENCES tcg.public.TCG_MTG_Inventory(inventory_id)
+    , display_order INT NOT NULL
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_Inventory_Link_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_Inventory_Link_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Deck_Inventory_Link_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11205_tbl_TCG_MTG_Deck_Inventory_Link_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Deck_Inventory_Link_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, link_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Deck_Inventory_Link_Audit_link_id
+		FOREIGN KEY (link_id)
+		REFERENCES tcg.public.TCG_MTG_Deck_Inventory_Link(link_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Deck_Inventory_Link_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11208_tbl_TCG_MTG_Game.sql

@@ -0,0 +1,27 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game (
+	  game_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , notes TEXT
+    , is_commander BOOLEAN NOT NULL DEFAULT TRUE
+    , is_draft BOOLEAN NOT NULL DEFAULT FALSE
+    , is_sealed BOOLEAN NOT NULL DEFAULT FALSE
+    , location_name TEXT
+    , start_on TIMESTAMP
+    , end_on TIMESTAMP
+    , starting_life INT
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11209_tbl_TCG_MTG_Game_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, game_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Game_Audit_game_id
+		FOREIGN KEY (game_id)
+		REFERENCES tcg.public.TCG_MTG_Game(game_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Game_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11212_tbl_TCG_MTG_Game_Player.sql

@@ -0,0 +1,34 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game_Player (
+	  player_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , game_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Player_game_id
+        FOREIGN KEY (game_id)
+        REFERENCES tcg.public.TCG_MTG_Game(game_id)
+    , user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Player_user_id
+        FOREIGN KEY (user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , deck_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Player_deck_id
+        FOREIGN KEY (deck_id)
+        REFERENCES tcg.public.TCG_MTG_Deck(deck_id)
+    , name TEXT
+    , notes TEXT
+    , display_order INT NOT NULL
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Player_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Player_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Player_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11213_tbl_TCG_MTG_Game_Player_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game_Player_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, player_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Game_Player_Audit_player_id
+		FOREIGN KEY (player_id)
+		REFERENCES tcg.public.TCG_MTG_Game_Player(player_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Game_Player_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11214_tbl_TCG_MTG_Game_Player_Temp.sql

@@ -0,0 +1,18 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game_Player_Temp (
+	  temp_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , guid UUID NOT NULL
+    , player_id INT
+    , game_id INT
+    , user_id INT
+    , deck_id INT
+    , name TEXT
+    , notes TEXT
+    , display_order INT
+    , active BOOLEAN
+	, created_on TIMESTAMP
+	, created_by_user_id INT
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+    , change_set_id INT
+);

static/PostgreSQL/11216_tbl_TCG_MTG_Game_Round.sql

@@ -0,0 +1,25 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game_Round (
+	  round_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, game_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Round_game_id
+        FOREIGN KEY (game_id)
+        REFERENCES tcg.public.TCG_MTG_Game(game_id)
+    , notes TEXT
+    , display_order INT NOT NULL
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Round_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Round_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Round_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11217_tbl_TCG_MTG_Game_Round_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game_Round_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, round_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Game_Round_Audit_round_id
+		FOREIGN KEY (round_id)
+		REFERENCES tcg.public.TCG_MTG_Game_Round(round_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Game_Round_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11218_tbl_TCG_MTG_Game_Round_Temp.sql

@@ -0,0 +1,14 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game_Round_Temp (
+	  temp_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , guid UUID NOT NULL
+    , round_id INT
+	, game_id INT
+    , notes TEXT
+    , display_order INT
+    , active BOOLEAN
+	, created_on TIMESTAMP
+	, created_by_user_id INT
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+);

static/PostgreSQL/11220_tbl_TCG_MTG_Game_Round_Player_Damage.sql

@@ -0,0 +1,33 @@
+CREATE TABLE tcg.public.TCG_MTG_Game_Round_Player_Damage (
+	  damage_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , round_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Round_Player_Damage_round_id
+        FOREIGN KEY (round_id)
+        REFERENCES tcg.public.TCG_MTG_Game_Round(round_id)
+    , player_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Round_Player_Damage_player_id
+        FOREIGN KEY (player_id)
+        REFERENCES tcg.public.TCG_MTG_Game_Player(player_id)
+    , received_from_commander_player_id INT
+    , CONSTRAINT FK_TCG_MTG_Game_Round_Player_Damage_received_from_commander_player_id
+        FOREIGN KEY (received_from_commander_player_id)
+        REFERENCES tcg.public.TCG_MTG_Game_Player(player_id)
+    , health_change INT NOT NULL
+    , commander_deaths INT NOT NULL
+    , is_eliminated BOOLEAN NOT NULL DEFAULT FALSE
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Round_Player_Damage_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP NOT NULL
+	, updated_last_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Round_Player_Damage_updated_last_by_user_id
+        FOREIGN KEY (updated_last_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+    , change_set_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Game_Round_Player_Damage_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11221_tbl_TCG_MTG_Game_Round_Player_Damage_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game_Round_Player_Damage_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, damage_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Game_Round_Player_Damage_Audit_damage_id
+		FOREIGN KEY (damage_id)
+		REFERENCES tcg.public.TCG_MTG_Game_Round_Player_Damage(damage_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Game_Round_Player_Damage_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/11222_tbl_TCG_MTG_Game_Round_Player_Damage_Temp.sql

@@ -0,0 +1,16 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Game_Round_Player_Damage_Temp (
+	  temp_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+    , guid UUID NOT NULL
+    , damage_id INT
+    , round_id INT
+    , player_id INT
+    , received_from_commander_player_id INT
+    , health_change INT
+    , commander_deaths INT
+    , active BOOLEAN
+	, created_on TIMESTAMP
+	, created_by_user_id INT
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+);

static/PostgreSQL/30500_tri_TCG_Change_Set.sql

@@ -0,0 +1,20 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_Change_Set()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_Change_Set
+    BEFORE INSERT ON tcg.public.TCG_Change_Set
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_Change_Set()
+;
+CREATE TRIGGER TRI_before_update_TCG_Change_Set
+    BEFORE UPDATE ON tcg.public.TCG_Change_Set
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_Change_Set()
+;

static/PostgreSQL/30504_tri_TCG_User.sql

@@ -0,0 +1,76 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_User()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.created_on = CURRENT_TIMESTAMP;
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_User()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_User_Audit (
+		  user_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed user_auth0_id
+	SELECT NEW.user_id, 'user_auth0_id', OLD.user_auth0_id, NEW.user_auth0_id, NEW.change_set_id
+		WHERE OLD.user_auth0_id IS NOT DISTINCT FROM NEW.user_auth0_id
+	UNION
+	-- Changed firstname
+	SELECT NEW.user_id, 'firstname', OLD.firstname, NEW.firstname, NEW.change_set_id
+		WHERE OLD.firstname IS NOT DISTINCT FROM NEW.firstname
+	UNION
+	-- Changed surname
+	SELECT NEW.user_id, 'surname', OLD.surname, NEW.surname, NEW.change_set_id
+		WHERE OLD.surname IS NOT DISTINCT FROM NEW.surname
+	UNION
+	-- Changed email
+	SELECT NEW.user_id, 'email', OLD.email, NEW.email, NEW.change_set_id
+		WHERE OLD.email IS NOT DISTINCT FROM NEW.email
+	UNION
+	-- Changed is_email_verified
+	SELECT NEW.user_id, 'is_email_verified', OLD.is_email_verified::TEXT, NEW.is_email_verified::TEXT, NEW.change_set_id
+		WHERE OLD.is_email_verified IS NOT DISTINCT FROM NEW.is_email_verified
+	UNION
+	-- Changed is_super_user
+	SELECT NEW.user_id, 'is_super_user', OLD.is_super_user::TEXT, NEW.is_super_user::TEXT, NEW.change_set_id
+		WHERE OLD.is_super_user IS NOT DISTINCT FROM NEW.is_super_user
+	UNION
+	-- Changed active
+	SELECT NEW.user_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_User
+    BEFORE INSERT ON tcg.public.TCG_User
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_User()
+;
+CREATE TRIGGER TRI_before_update_TCG_User
+    BEFORE UPDATE ON tcg.public.TCG_User
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_User()
+;

static/PostgreSQL/30510_tri_Error_Type.sql

@@ -0,0 +1,76 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_Error_Type()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_Error_Type()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.Error_Type_Audit (
+		  error_type_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed code
+	SELECT NEW.error_type_id, 'code', OLD.code, NEW.code, NEW.change_set_id
+		WHERE OLD.code IS NOT DISTINCT FROM NEW.code
+	UNION
+	-- Changed name
+	SELECT NEW.error_type_id, 'name', OLD.name, NEW.name, NEW.change_set_id
+		WHERE OLD.name IS NOT DISTINCT FROM NEW.name
+	UNION
+	-- Changed active
+	SELECT NEW.error_type_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_Error_Type
+    BEFORE INSERT ON tcg.public.Error_Type
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_Error_Type()
+;
+CREATE TRIGGER TRI_before_update_Error_Type
+    BEFORE UPDATE ON tcg.public.Error_Type
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_Error_Type()
+;

static/PostgreSQL/30514_tri_Error.sql

@@ -0,0 +1,84 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_Error()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_Error()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.Error_Audit (
+		  error_id
+        , message_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed guid
+	SELECT NEW.error_id, 'guid', OLD.guid::TEXT, NEW.guid::TEXT, NEW.change_set_id
+		WHERE OLD.guid IS NOT DISTINCT FROM NEW.guid
+	UNION
+	-- Changed error_type_id
+	SELECT NEW.error_id, 'error_type_id', OLD.error_type_id::TEXT, NEW.error_type_id::TEXT, NEW.change_set_id
+		WHERE OLD.error_type_id IS NOT DISTINCT FROM NEW.error_type_id
+	UNION
+	-- Changed message
+	SELECT NEW.error_id, 'message', OLD.message, NEW.message, NEW.change_set_id
+		WHERE OLD.message IS NOT DISTINCT FROM NEW.message
+	UNION
+	-- Changed display_order
+	SELECT NEW.error_id, 'display_order', OLD.display_order::TEXT, NEW.display_order::TEXT, NEW.change_set_id
+		WHERE OLD.display_order IS NOT DISTINCT FROM NEW.display_order
+	UNION
+	-- Changed active
+	SELECT NEW.error_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_Error
+    BEFORE INSERT ON tcg.public.Error
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_Error()
+;
+CREATE TRIGGER TRI_before_update_Error
+    BEFORE UPDATE ON tcg.public.Error
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_Error()
+;

static/PostgreSQL/31001_tri_TCG_Condition.sql

@@ -0,0 +1,96 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_Condition()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_Condition()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_Condition_Audit (
+		  condition_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed name
+	SELECT NEW.condition_id, 'name', OLD.name, NEW.name, NEW.change_set_id
+		WHERE OLD.name IS NOT DISTINCT FROM NEW.name
+	UNION
+	-- Changed code
+	SELECT NEW.condition_id, 'code', OLD.code, NEW.code, NEW.change_set_id
+		WHERE OLD.code IS NOT DISTINCT FROM NEW.code
+	UNION
+	-- Changed description
+	SELECT NEW.condition_id, 'description', OLD.description, NEW.description, NEW.change_set_id
+		WHERE OLD.description IS NOT DISTINCT FROM NEW.description
+	UNION
+	-- Changed summary
+	SELECT NEW.condition_id, 'summary', OLD.summary, NEW.summary, NEW.change_set_id
+		WHERE OLD.summary IS NOT DISTINCT FROM NEW.summary
+	UNION
+	-- Changed us_name
+	SELECT NEW.condition_id, 'us_name', OLD.us_name, NEW.us_name, NEW.change_set_id
+		WHERE OLD.us_name IS NOT DISTINCT FROM NEW.us_name
+	UNION
+	-- Changed price_ratio_min
+	SELECT NEW.condition_id, 'price_ratio_min', OLD.price_ratio_min::TEXT, NEW.price_ratio_min::TEXT, NEW.change_set_id
+		WHERE OLD.price_ratio_min IS NOT DISTINCT FROM NEW.price_ratio_min
+	UNION
+	-- Changed price_ratio_max
+	SELECT NEW.condition_id, 'price_ratio_max', OLD.price_ratio_max::TEXT, NEW.price_ratio_max::TEXT, NEW.change_set_id
+		WHERE OLD.price_ratio_max IS NOT DISTINCT FROM NEW.price_ratio_max
+	UNION
+	-- Changed active
+	SELECT NEW.condition_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_Condition
+    BEFORE INSERT ON tcg.public.TCG_Condition
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_Condition()
+;
+CREATE TRIGGER TRI_before_update_TCG_Condition
+    BEFORE UPDATE ON tcg.public.TCG_Condition
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_Condition()
+;

static/PostgreSQL/31101_tri_TCG_MTG_Finish.sql

@@ -0,0 +1,84 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Finish()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Finish()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Finish_Audit (
+		  finish_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed name
+	SELECT NEW.finish_id, 'name', OLD.name, NEW.name, NEW.change_set_id
+		WHERE OLD.name IS NOT DISTINCT FROM NEW.name
+	UNION
+	-- Changed description
+	SELECT NEW.finish_id, 'description', OLD.description, NEW.description, NEW.change_set_id
+		WHERE OLD.description IS NOT DISTINCT FROM NEW.description
+	UNION
+	-- Changed price_ratio_min
+	SELECT NEW.finish_id, 'price_ratio_min', OLD.price_ratio_min::TEXT, NEW.price_ratio_min::TEXT, NEW.change_set_id
+		WHERE OLD.price_ratio_min IS NOT DISTINCT FROM NEW.price_ratio_min
+	UNION
+	-- Changed price_ratio_max
+	SELECT NEW.finish_id, 'price_ratio_max', OLD.price_ratio_max::TEXT, NEW.price_ratio_max::TEXT, NEW.change_set_id
+		WHERE OLD.price_ratio_max IS NOT DISTINCT FROM NEW.price_ratio_max
+	UNION
+	-- Changed active
+	SELECT NEW.finish_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Finish
+    BEFORE INSERT ON tcg.public.TCG_MTG_Finish
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Finish()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Finish
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Finish
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Finish()
+;

static/PostgreSQL/31130_tri_TCG_MTG_Card.sql

@@ -0,0 +1,512 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Card()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Card()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Card_Audit (
+		  card_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed all_parts
+	SELECT NEW.card_id, 'all_parts', OLD.all_parts, NEW.all_parts, NEW.change_set_id
+		WHERE OLD.all_parts IS NOT DISTINCT FROM NEW.all_parts
+	UNION
+	-- Changed arena_id
+	SELECT NEW.card_id, 'arena_id', OLD.arena_id::TEXT, NEW.arena_id::TEXT, NEW.change_set_id
+		WHERE OLD.arena_id IS NOT DISTINCT FROM NEW.arena_id
+	UNION
+	-- Changed artist
+	SELECT NEW.card_id, 'artist', OLD.artist, NEW.artist, NEW.change_set_id
+		WHERE OLD.artist IS NOT DISTINCT FROM NEW.artist
+	UNION
+	-- Changed artist_ids
+	SELECT NEW.card_id, 'artist_ids', OLD.artist_ids, NEW.artist_ids, NEW.change_set_id
+		WHERE OLD.artist_ids IS NOT DISTINCT FROM NEW.artist_ids
+	UNION
+	-- Changed booster
+	SELECT NEW.card_id, 'booster', OLD.booster::TEXT, NEW.booster::TEXT, NEW.change_set_id
+		WHERE OLD.booster IS NOT DISTINCT FROM NEW.booster
+	UNION
+	-- Changed border_color
+	SELECT NEW.card_id, 'border_color', OLD.border_color, NEW.border_color, NEW.change_set_id
+		WHERE OLD.border_color IS NOT DISTINCT FROM NEW.border_color
+	UNION
+	-- Changed card_back_id
+	SELECT NEW.card_id, 'card_back_id', OLD.card_back_id, NEW.card_back_id, NEW.change_set_id
+		WHERE OLD.card_back_id IS NOT DISTINCT FROM NEW.card_back_id
+	UNION
+	-- Changed cmc
+	SELECT NEW.card_id, 'cmc', OLD.cmc::TEXT, NEW.cmc::TEXT, NEW.change_set_id
+		WHERE OLD.cmc IS NOT DISTINCT FROM NEW.cmc
+	UNION
+	-- Changed collector_number
+	SELECT NEW.card_id, 'collector_number', OLD.collector_number, NEW.collector_number, NEW.change_set_id
+		WHERE OLD.collector_number IS NOT DISTINCT FROM NEW.collector_number
+	UNION
+	-- Changed color_identity
+	SELECT NEW.card_id, 'color_identity', OLD.color_identity, NEW.color_identity, NEW.change_set_id
+		WHERE OLD.color_identity IS NOT DISTINCT FROM NEW.color_identity
+	UNION
+	-- Changed colors
+	SELECT NEW.card_id, 'colors', OLD.colors, NEW.colors, NEW.change_set_id
+		WHERE OLD.colors IS NOT DISTINCT FROM NEW.colors
+	UNION
+	-- Changed content_warning
+	SELECT NEW.card_id, 'content_warning', OLD.content_warning::TEXT, NEW.content_warning::TEXT, NEW.change_set_id
+		WHERE OLD.content_warning IS NOT DISTINCT FROM NEW.content_warning
+	UNION
+	-- Changed digital
+	SELECT NEW.card_id, 'digital', OLD.digital::TEXT, NEW.digital::TEXT, NEW.change_set_id
+		WHERE OLD.digital IS NOT DISTINCT FROM NEW.digital
+	UNION
+	-- Changed edhrec_rank
+	SELECT NEW.card_id, 'edhrec_rank', OLD.edhrec_rank::TEXT, NEW.edhrec_rank::TEXT, NEW.change_set_id
+		WHERE OLD.edhrec_rank IS NOT DISTINCT FROM NEW.edhrec_rank
+	UNION
+	-- Changed finishes
+	SELECT NEW.card_id, 'finishes', OLD.finishes, NEW.finishes, NEW.change_set_id
+		WHERE OLD.finishes IS NOT DISTINCT FROM NEW.finishes
+	UNION
+	-- Changed flavor_name
+	SELECT NEW.card_id, 'flavor_name', OLD.flavor_name, NEW.flavor_name, NEW.change_set_id
+		WHERE OLD.flavor_name IS NOT DISTINCT FROM NEW.flavor_name
+	UNION
+	-- Changed flavor_text
+	SELECT NEW.card_id, 'flavor_text', OLD.flavor_text, NEW.flavor_text, NEW.change_set_id
+		WHERE OLD.flavor_text IS NOT DISTINCT FROM NEW.flavor_text
+	UNION
+	-- Changed foil
+	SELECT NEW.card_id, 'foil', OLD.foil::TEXT, NEW.foil::TEXT, NEW.change_set_id
+		WHERE OLD.foil IS NOT DISTINCT FROM NEW.foil
+	UNION
+	-- Changed frame
+	SELECT NEW.card_id, 'frame', OLD.frame, NEW.frame, NEW.change_set_id
+		WHERE OLD.frame IS NOT DISTINCT FROM NEW.frame
+	UNION
+	-- Changed full_art
+	SELECT NEW.card_id, 'full_art', OLD.full_art::TEXT, NEW.full_art::TEXT, NEW.change_set_id
+		WHERE OLD.full_art IS NOT DISTINCT FROM NEW.full_art
+	UNION
+	-- Changed game_changer
+	SELECT NEW.card_id, 'game_changer', OLD.game_changer::TEXT, NEW.game_changer::TEXT, NEW.change_set_id
+		WHERE OLD.game_changer IS NOT DISTINCT FROM NEW.game_changer
+	UNION
+	-- Changed games
+	SELECT NEW.card_id, 'games', OLD.games, NEW.games, NEW.change_set_id
+		WHERE OLD.games IS NOT DISTINCT FROM NEW.games
+	UNION
+	-- Changed hand_modifier
+	SELECT NEW.card_id, 'hand_modifier', OLD.hand_modifier, NEW.hand_modifier, NEW.change_set_id
+		WHERE OLD.hand_modifier IS NOT DISTINCT FROM NEW.hand_modifier
+	UNION
+	-- Changed highres_image
+	SELECT NEW.card_id, 'highres_image', OLD.highres_image::TEXT, NEW.highres_image::TEXT, NEW.change_set_id
+		WHERE OLD.highres_image IS NOT DISTINCT FROM NEW.highres_image
+	UNION
+	-- Changed id
+	SELECT NEW.card_id, 'id', OLD.id::TEXT, NEW.id::TEXT, NEW.change_set_id
+		WHERE OLD.id IS NOT DISTINCT FROM NEW.id
+	UNION
+	-- Changed image_status
+	SELECT NEW.card_id, 'image_status', OLD.image_status, NEW.image_status, NEW.change_set_id
+		WHERE OLD.image_status IS NOT DISTINCT FROM NEW.image_status
+	UNION
+	-- Changed image_uri_art_crop
+	SELECT NEW.card_id, 'image_uri_art_crop', OLD.image_uri_art_crop, NEW.image_uri_art_crop, NEW.change_set_id
+		WHERE OLD.image_uri_art_crop IS NOT DISTINCT FROM NEW.image_uri_art_crop
+	UNION
+	-- Changed image_uri_border_crop
+	SELECT NEW.card_id, 'image_uri_border_crop', OLD.image_uri_border_crop, NEW.image_uri_border_crop, NEW.change_set_id
+		WHERE OLD.image_uri_border_crop IS NOT DISTINCT FROM NEW.image_uri_border_crop
+	UNION
+	-- Changed image_uri_large
+	SELECT NEW.card_id, 'image_uri_large', OLD.image_uri_large, NEW.image_uri_large, NEW.change_set_id
+		WHERE OLD.image_uri_large IS NOT DISTINCT FROM NEW.image_uri_large
+	UNION
+	-- Changed image_uri_normal
+	SELECT NEW.card_id, 'image_uri_normal', OLD.image_uri_normal, NEW.image_uri_normal, NEW.change_set_id
+		WHERE OLD.image_uri_normal IS NOT DISTINCT FROM NEW.image_uri_normal
+	UNION
+	-- Changed image_uri_png
+	SELECT NEW.card_id, 'image_uri_png', OLD.image_uri_png, NEW.image_uri_png, NEW.change_set_id
+		WHERE OLD.image_uri_png IS NOT DISTINCT FROM NEW.image_uri_png
+	UNION
+	-- Changed image_uri_small
+	SELECT NEW.card_id, 'image_uri_small', OLD.image_uri_small, NEW.image_uri_small, NEW.change_set_id
+		WHERE OLD.image_uri_small IS NOT DISTINCT FROM NEW.image_uri_small
+	UNION
+	-- Changed keywords
+	SELECT NEW.card_id, 'keywords', OLD.keywords, NEW.keywords, NEW.change_set_id
+		WHERE OLD.keywords IS NOT DISTINCT FROM NEW.keywords
+	UNION
+	-- Changed lang
+	SELECT NEW.card_id, 'lang', OLD.lang, NEW.lang, NEW.change_set_id
+		WHERE OLD.lang IS NOT DISTINCT FROM NEW.lang
+	UNION
+	-- Changed layout
+	SELECT NEW.card_id, 'layout', OLD.layout, NEW.layout, NEW.change_set_id
+		WHERE OLD.layout IS NOT DISTINCT FROM NEW.layout
+	UNION
+	-- Changed legal_alchemy
+	SELECT NEW.card_id, 'legal_alchemy', OLD.legal_alchemy::TEXT, NEW.legal_alchemy::TEXT, NEW.change_set_id
+		WHERE OLD.legal_alchemy IS NOT DISTINCT FROM NEW.legal_alchemy
+	UNION
+	-- Changed legal_brawl
+	SELECT NEW.card_id, 'legal_brawl', OLD.legal_brawl::TEXT, NEW.legal_brawl::TEXT, NEW.change_set_id
+		WHERE OLD.legal_brawl IS NOT DISTINCT FROM NEW.legal_brawl
+	UNION
+	-- Changed legal_commander
+	SELECT NEW.card_id, 'legal_commander', OLD.legal_commander::TEXT, NEW.legal_commander::TEXT, NEW.change_set_id
+		WHERE OLD.legal_commander IS NOT DISTINCT FROM NEW.legal_commander
+	UNION
+	-- Changed legal_duel
+	SELECT NEW.card_id, 'legal_duel', OLD.legal_duel::TEXT, NEW.legal_duel::TEXT, NEW.change_set_id
+		WHERE OLD.legal_duel IS NOT DISTINCT FROM NEW.legal_duel
+	UNION
+	-- Changed legal_future
+	SELECT NEW.card_id, 'legal_future', OLD.legal_future::TEXT, NEW.legal_future::TEXT, NEW.change_set_id
+		WHERE OLD.legal_future IS NOT DISTINCT FROM NEW.legal_future
+	UNION
+	-- Changed legal_gladiator
+	SELECT NEW.card_id, 'legal_gladiator', OLD.legal_gladiator::TEXT, NEW.legal_gladiator::TEXT, NEW.change_set_id
+		WHERE OLD.legal_gladiator IS NOT DISTINCT FROM NEW.legal_gladiator
+	UNION
+	-- Changed legal_historic
+	SELECT NEW.card_id, 'legal_historic', OLD.legal_historic::TEXT, NEW.legal_historic::TEXT, NEW.change_set_id
+		WHERE OLD.legal_historic IS NOT DISTINCT FROM NEW.legal_historic
+	UNION
+	-- Changed legal_legacy
+	SELECT NEW.card_id, 'legal_legacy', OLD.legal_legacy::TEXT, NEW.legal_legacy::TEXT, NEW.change_set_id
+		WHERE OLD.legal_legacy IS NOT DISTINCT FROM NEW.legal_legacy
+	UNION
+	-- Changed legal_modern
+	SELECT NEW.card_id, 'legal_modern', OLD.legal_modern::TEXT, NEW.legal_modern::TEXT, NEW.change_set_id
+		WHERE OLD.legal_modern IS NOT DISTINCT FROM NEW.legal_modern
+	UNION
+	-- Changed legal_oathbreaker
+	SELECT NEW.card_id, 'legal_oathbreaker', OLD.legal_oathbreaker::TEXT, NEW.legal_oathbreaker::TEXT, NEW.change_set_id
+		WHERE OLD.legal_oathbreaker IS NOT DISTINCT FROM NEW.legal_oathbreaker
+	UNION
+	-- Changed legal_oldschool
+	SELECT NEW.card_id, 'legal_oldschool', OLD.legal_oldschool::TEXT, NEW.legal_oldschool::TEXT, NEW.change_set_id
+		WHERE OLD.legal_oldschool IS NOT DISTINCT FROM NEW.legal_oldschool
+	UNION
+	-- Changed legal_pauper
+	SELECT NEW.card_id, 'legal_pauper', OLD.legal_pauper::TEXT, NEW.legal_pauper::TEXT, NEW.change_set_id
+		WHERE OLD.legal_pauper IS NOT DISTINCT FROM NEW.legal_pauper
+	UNION
+	-- Changed legal_paupercommander
+	SELECT NEW.card_id, 'legal_paupercommander', OLD.legal_paupercommander::TEXT, NEW.legal_paupercommander::TEXT, NEW.change_set_id
+		WHERE OLD.legal_paupercommander IS NOT DISTINCT FROM NEW.legal_paupercommander
+	UNION
+	-- Changed legal_penny
+	SELECT NEW.card_id, 'legal_penny', OLD.legal_penny::TEXT, NEW.legal_penny::TEXT, NEW.change_set_id
+		WHERE OLD.legal_penny IS NOT DISTINCT FROM NEW.legal_penny
+	UNION
+	-- Changed legal_pioneer
+	SELECT NEW.card_id, 'legal_pioneer', OLD.legal_pioneer::TEXT, NEW.legal_pioneer::TEXT, NEW.change_set_id
+		WHERE OLD.legal_pioneer IS NOT DISTINCT FROM NEW.legal_pioneer
+	UNION
+	-- Changed legal_predh
+	SELECT NEW.card_id, 'legal_predh', OLD.legal_predh::TEXT, NEW.legal_predh::TEXT, NEW.change_set_id
+		WHERE OLD.legal_predh IS NOT DISTINCT FROM NEW.legal_predh
+	UNION
+	-- Changed legal_premodern
+	SELECT NEW.card_id, 'legal_premodern', OLD.legal_premodern::TEXT, NEW.legal_premodern::TEXT, NEW.change_set_id
+		WHERE OLD.legal_premodern IS NOT DISTINCT FROM NEW.legal_premodern
+	UNION
+	-- Changed legal_standard
+	SELECT NEW.card_id, 'legal_standard', OLD.legal_standard::TEXT, NEW.legal_standard::TEXT, NEW.change_set_id
+		WHERE OLD.legal_standard IS NOT DISTINCT FROM NEW.legal_standard
+	UNION
+	-- Changed legal_standardbrawl
+	SELECT NEW.card_id, 'legal_standardbrawl', OLD.legal_standardbrawl::TEXT, NEW.legal_standardbrawl::TEXT, NEW.change_set_id
+		WHERE OLD.legal_standardbrawl IS NOT DISTINCT FROM NEW.legal_standardbrawl
+	UNION
+	-- Changed legal_timeless
+	SELECT NEW.card_id, 'legal_timeless', OLD.legal_timeless::TEXT, NEW.legal_timeless::TEXT, NEW.change_set_id
+		WHERE OLD.legal_timeless IS NOT DISTINCT FROM NEW.legal_timeless
+	UNION
+	-- Changed legal_vintage
+	SELECT NEW.card_id, 'legal_vintage', OLD.legal_vintage::TEXT, NEW.legal_vintage::TEXT, NEW.change_set_id
+		WHERE OLD.legal_vintage IS NOT DISTINCT FROM NEW.legal_vintage
+    UNION
+	-- Changed life_modifier
+	SELECT NEW.card_id, 'life_modifier', OLD.life_modifier, NEW.life_modifier, NEW.change_set_id
+		WHERE OLD.life_modifier IS NOT DISTINCT FROM NEW.life_modifier
+    UNION
+	-- Changed loyalty
+	SELECT NEW.card_id, 'loyalty', OLD.loyalty, NEW.loyalty, NEW.change_set_id
+		WHERE OLD.loyalty IS NOT DISTINCT FROM NEW.loyalty
+    UNION
+	-- Changed mana_cost
+	SELECT NEW.card_id, 'mana_cost', OLD.mana_cost, NEW.mana_cost, NEW.change_set_id
+		WHERE OLD.mana_cost IS NOT DISTINCT FROM NEW.mana_cost
+	UNION
+	-- Changed mtgo_id
+	SELECT NEW.card_id, 'mtgo_id', OLD.mtgo_id::TEXT, NEW.mtgo_id::TEXT, NEW.change_set_id
+		WHERE OLD.mtgo_id IS NOT DISTINCT FROM NEW.mtgo_id
+    UNION
+	-- Changed multiverse_ids
+	SELECT NEW.card_id, 'multiverse_ids', OLD.multiverse_ids, NEW.multiverse_ids, NEW.change_set_id
+		WHERE OLD.multiverse_ids IS NOT DISTINCT FROM NEW.multiverse_ids
+    UNION
+	-- Changed name
+	SELECT NEW.card_id, 'name', OLD.name, NEW.name, NEW.change_set_id
+		WHERE OLD.name IS NOT DISTINCT FROM NEW.name
+	UNION
+	-- Changed nonfoil
+	SELECT NEW.card_id, 'nonfoil', OLD.nonfoil::TEXT, NEW.nonfoil::TEXT, NEW.change_set_id
+		WHERE OLD.nonfoil IS NOT DISTINCT FROM NEW.nonfoil
+	UNION
+	-- Changed oracle_id
+	SELECT NEW.card_id, 'oracle_id', OLD.oracle_id::TEXT, NEW.oracle_id::TEXT, NEW.change_set_id
+		WHERE OLD.oracle_id IS NOT DISTINCT FROM NEW.oracle_id
+    UNION
+	-- Changed oracle_text
+	SELECT NEW.card_id, 'oracle_text', OLD.oracle_text, NEW.oracle_text, NEW.change_set_id
+		WHERE OLD.oracle_text IS NOT DISTINCT FROM NEW.oracle_text
+	UNION
+	-- Changed oversized
+	SELECT NEW.card_id, 'oversized', OLD.oversized::TEXT, NEW.oversized::TEXT, NEW.change_set_id
+		WHERE OLD.oversized IS NOT DISTINCT FROM NEW.oversized
+	UNION
+	-- Changed penny_rank
+	SELECT NEW.card_id, 'penny_rank', OLD.penny_rank::TEXT, NEW.penny_rank::TEXT, NEW.change_set_id
+		WHERE OLD.penny_rank IS NOT DISTINCT FROM NEW.penny_rank
+    UNION
+	-- Changed power
+	SELECT NEW.card_id, 'power', OLD.power, NEW.power, NEW.change_set_id
+		WHERE OLD.power IS NOT DISTINCT FROM NEW.power
+	UNION
+	-- Changed preview_date
+	SELECT NEW.card_id, 'preview_date', TO_CHAR(OLD.preview_date, 'YYYY-MM-DD'), TO_CHAR(NEW.preview_date, 'YYYY-MM-DD'), NEW.change_set_id
+		WHERE OLD.preview_date IS NOT DISTINCT FROM NEW.preview_date
+    UNION
+	-- Changed preview_source
+	SELECT NEW.card_id, 'preview_source', OLD.preview_source, NEW.preview_source, NEW.change_set_id
+		WHERE OLD.preview_source IS NOT DISTINCT FROM NEW.preview_source
+    UNION
+	-- Changed preview_source_uri
+	SELECT NEW.card_id, 'preview_source_uri', OLD.preview_source_uri, NEW.preview_source_uri, NEW.change_set_id
+		WHERE OLD.preview_source_uri IS NOT DISTINCT FROM NEW.preview_source_uri
+	UNION
+	-- Changed price_eur
+	SELECT NEW.card_id, 'price_eur', OLD.price_eur::TEXT, NEW.price_eur::TEXT, NEW.change_set_id
+		WHERE OLD.price_eur IS NOT DISTINCT FROM NEW.price_eur
+	UNION
+	-- Changed price_eur_foil
+	SELECT NEW.card_id, 'price_eur_foil', OLD.price_eur_foil::TEXT, NEW.price_eur_foil::TEXT, NEW.change_set_id
+		WHERE OLD.price_eur_foil IS NOT DISTINCT FROM NEW.price_eur_foil
+	UNION
+	-- Changed price_tix
+	SELECT NEW.card_id, 'price_tix', OLD.price_tix::TEXT, NEW.price_tix::TEXT, NEW.change_set_id
+		WHERE OLD.price_tix IS NOT DISTINCT FROM NEW.price_tix
+	UNION
+	-- Changed price_usd
+	SELECT NEW.card_id, 'price_usd', OLD.price_usd::TEXT, NEW.price_usd::TEXT, NEW.change_set_id
+		WHERE OLD.price_usd IS NOT DISTINCT FROM NEW.price_usd
+	UNION
+	-- Changed price_usd_etched
+	SELECT NEW.card_id, 'price_usd_etched', OLD.price_usd_etched::TEXT, NEW.price_usd_etched::TEXT, NEW.change_set_id
+		WHERE OLD.price_usd_etched IS NOT DISTINCT FROM NEW.price_usd_etched
+	UNION
+	-- Changed price_usd_foil
+	SELECT NEW.card_id, 'price_usd_foil', OLD.price_usd_foil::TEXT, NEW.price_usd_foil::TEXT, NEW.change_set_id
+		WHERE OLD.price_usd_foil IS NOT DISTINCT FROM NEW.price_usd_foil
+    UNION
+	-- Changed printed_name
+	SELECT NEW.card_id, 'printed_name', OLD.printed_name, NEW.printed_name, NEW.change_set_id
+		WHERE OLD.printed_name IS NOT DISTINCT FROM NEW.printed_name
+    UNION
+	-- Changed printed_text
+	SELECT NEW.card_id, 'printed_text', OLD.printed_text, NEW.printed_text, NEW.change_set_id
+		WHERE OLD.printed_text IS NOT DISTINCT FROM NEW.printed_text
+    UNION
+	-- Changed printed_type_line
+	SELECT NEW.card_id, 'printed_type_line', OLD.printed_type_line, NEW.printed_type_line, NEW.change_set_id
+		WHERE OLD.printed_type_line IS NOT DISTINCT FROM NEW.printed_type_line
+    UNION
+	-- Changed prints_search_uri
+	SELECT NEW.card_id, 'printed_search_uri', OLD.printed_search_uri, NEW.printed_search_uri, NEW.change_set_id
+		WHERE OLD.printed_search_uri IS NOT DISTINCT FROM NEW.printed_search_uri
+    UNION
+	-- Changed produced_mana
+	SELECT NEW.card_id, 'produced_mana', OLD.produced_mana, NEW.produced_mana, NEW.change_set_id
+		WHERE OLD.produced_mana IS NOT DISTINCT FROM NEW.produced_mana
+	UNION
+	-- Changed promo
+	SELECT NEW.card_id, 'promo', OLD.promo::TEXT, NEW.promo::TEXT, NEW.change_set_id
+		WHERE OLD.promo IS NOT DISTINCT FROM NEW.promo
+    UNION
+	-- Changed purchase_cardhoarder
+	SELECT NEW.card_id, 'purchase_cardhoarder', OLD.purchase_cardhoarder, NEW.purchase_cardhoarder, NEW.change_set_id
+		WHERE OLD.purchase_cardhoarder IS NOT DISTINCT FROM NEW.purchase_cardhoarder
+    UNION
+	-- Changed purchase_cardmarket
+	SELECT NEW.card_id, 'purchase_cardmarket', OLD.purchase_cardmarket, NEW.purchase_cardmarket, NEW.change_set_id
+		WHERE OLD.purchase_cardmarket IS NOT DISTINCT FROM NEW.purchase_cardmarket
+    UNION
+	-- Changed purchase_tcgplayer
+	SELECT NEW.card_id, 'purchase_tcgplayer', OLD.purchase_tcgplayer, NEW.purchase_tcgplayer, NEW.change_set_id
+		WHERE OLD.purchase_tcgplayer IS NOT DISTINCT FROM NEW.purchase_tcgplayer
+    UNION
+	-- Changed rarity
+	SELECT NEW.card_id, 'rarity', OLD.rarity, NEW.rarity, NEW.change_set_id
+		WHERE OLD.rarity IS NOT DISTINCT FROM NEW.rarity
+	UNION
+	-- Changed released_at
+	SELECT NEW.card_id, 'released_at', TO_CHAR(OLD.released_at, 'YYYY-MM-DD'), TO_CHAR(NEW.released_at, 'YYYY-MM-DD'), NEW.change_set_id
+		WHERE OLD.released_at IS NOT DISTINCT FROM NEW.released_at
+	UNION
+	-- Changed reprint
+	SELECT NEW.card_id, 'reprint', OLD.reprint::TEXT, NEW.reprint::TEXT, NEW.change_set_id
+		WHERE OLD.reprint IS NOT DISTINCT FROM NEW.reprint
+	UNION
+	-- Changed reserved
+	SELECT NEW.card_id, 'reserved', OLD.reserved::TEXT, NEW.reserved::TEXT, NEW.change_set_id
+		WHERE OLD.reserved IS NOT DISTINCT FROM NEW.reserved
+    UNION
+	-- Changed rulings_uri
+	SELECT NEW.card_id, 'rulings_uri', OLD.rulings_uri, NEW.rulings_uri, NEW.change_set_id
+		WHERE OLD.rulings_uri IS NOT DISTINCT FROM NEW.rulings_uri
+    UNION
+	-- Changed scryfall_set_uri
+	SELECT NEW.card_id, 'scryfall_set_uri', OLD.scryfall_set_uri, NEW.scryfall_set_uri, NEW.change_set_id
+		WHERE OLD.scryfall_set_uri IS NOT DISTINCT FROM NEW.scryfall_set_uri
+    UNION
+	-- Changed scryfall_uri
+	SELECT NEW.card_id, 'scryfall_uri', OLD.scryfall_uri, NEW.scryfall_uri, NEW.change_set_id
+		WHERE OLD.scryfall_uri IS NOT DISTINCT FROM NEW.scryfall_uri
+    UNION
+	-- Changed security_stamp
+	SELECT NEW.card_id, 'security_stamp', OLD.security_stamp, NEW.security_stamp, NEW.change_set_id
+		WHERE OLD.security_stamp IS NOT DISTINCT FROM NEW.security_stamp
+    UNION
+	-- Changed set
+	SELECT NEW.card_id, 'set', OLD.set, NEW.set, NEW.change_set_id
+		WHERE OLD.set IS NOT DISTINCT FROM NEW.set
+	UNION
+	-- Changed set_id
+	SELECT NEW.card_id, 'set_id', OLD.set_id::TEXT, NEW.set_id::TEXT, NEW.change_set_id
+		WHERE OLD.set_id IS NOT DISTINCT FROM NEW.set_id
+    UNION
+	-- Changed set_name
+	SELECT NEW.card_id, 'set_name', OLD.set_name, NEW.set_name, NEW.change_set_id
+		WHERE OLD.set_name IS NOT DISTINCT FROM NEW.set_name
+    UNION
+	-- Changed set_search_uri
+	SELECT NEW.card_id, 'set_search_uri', OLD.set_search_uri, NEW.set_search_uri, NEW.change_set_id
+		WHERE OLD.set_search_uri IS NOT DISTINCT FROM NEW.set_search_uri
+    UNION
+	-- Changed set_type
+	SELECT NEW.card_id, 'set_type', OLD.set_type, NEW.set_type, NEW.change_set_id
+		WHERE OLD.set_type IS NOT DISTINCT FROM NEW.set_type
+    UNION
+	-- Changed set_uri
+	SELECT NEW.card_id, 'set_uri', OLD.set_uri, NEW.set_uri, NEW.change_set_id
+		WHERE OLD.set_uri IS NOT DISTINCT FROM NEW.set_uri
+	UNION
+	-- Changed story_spotlight
+	SELECT NEW.card_id, 'story_spotlight', OLD.story_spotlight::TEXT, NEW.story_spotlight::TEXT, NEW.change_set_id
+		WHERE OLD.story_spotlight IS NOT DISTINCT FROM NEW.story_spotlight
+	UNION
+	-- Changed tcgplayer_id
+	SELECT NEW.card_id, 'tcgplayer_id', OLD.tcgplayer_id::TEXT, NEW.tcgplayer_id::TEXT, NEW.change_set_id
+		WHERE OLD.tcgplayer_id IS NOT DISTINCT FROM NEW.tcgplayer_id
+	UNION
+	-- Changed textless
+	SELECT NEW.card_id, 'textless', OLD.textless::TEXT, NEW.textless::TEXT, NEW.change_set_id
+		WHERE OLD.textless IS NOT DISTINCT FROM NEW.textless
+    UNION
+	-- Changed toughness
+	SELECT NEW.card_id, 'toughness', OLD.toughness, NEW.toughness, NEW.change_set_id
+		WHERE OLD.toughness IS NOT DISTINCT FROM NEW.toughness
+    UNION
+	-- Changed type_line
+	SELECT NEW.card_id, 'type_line', OLD.type_line, NEW.type_line, NEW.change_set_id
+		WHERE OLD.type_line IS NOT DISTINCT FROM NEW.type_line
+    UNION
+	-- Changed uri
+	SELECT NEW.card_id, 'uri', OLD.uri, NEW.uri, NEW.change_set_id
+		WHERE OLD.uri IS NOT DISTINCT FROM NEW.uri
+    UNION
+	-- Changed uri_edhrec
+	SELECT NEW.card_id, 'uri_edhrec', OLD.uri_edhrec, NEW.uri_edhrec, NEW.change_set_id
+		WHERE OLD.uri_edhrec IS NOT DISTINCT FROM NEW.uri_edhrec
+    UNION
+	-- Changed uri_gatherer
+	SELECT NEW.card_id, 'uri_gatherer', OLD.uri_gatherer, NEW.uri_gatherer, NEW.change_set_id
+		WHERE OLD.uri_gatherer IS NOT DISTINCT FROM NEW.uri_gatherer
+    UNION
+	-- Changed uri_tcgplayer_infinite_articles
+	SELECT NEW.card_id, 'uri_tcgplayer_infinite_articles', OLD.uri_tcgplayer_infinite_articles, NEW.uri_tcgplayer_infinite_articles, NEW.change_set_id
+		WHERE OLD.uri_tcgplayer_infinite_articles IS NOT DISTINCT FROM NEW.uri_tcgplayer_infinite_articles
+    UNION
+	-- Changed uri_tcgplayer_infinite_decks
+	SELECT NEW.card_id, 'uri_tcgplayer_infinite_decks', OLD.uri_tcgplayer_infinite_decks, NEW.uri_tcgplayer_infinite_decks, NEW.change_set_id
+		WHERE OLD.uri_tcgplayer_infinite_decks IS NOT DISTINCT FROM NEW.uri_tcgplayer_infinite_decks
+	UNION
+	-- Changed variation
+	SELECT NEW.card_id, 'variation', OLD.variation::TEXT, NEW.variation::TEXT, NEW.change_set_id
+		WHERE OLD.variation IS NOT DISTINCT FROM NEW.variation
+    UNION
+	-- Changed active
+	SELECT NEW.card_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Card
+    BEFORE INSERT ON tcg.public.TCG_MTG_Card
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Card()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Card
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Card
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Card()
+;

static/PostgreSQL/31150_tri_TCG_MTG_Inventory.sql

@@ -0,0 +1,196 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Inventory()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Inventory()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Inventory_Audit (
+		  inventory_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed card_id
+	SELECT NEW.inventory_id, 'card_id', OLD.card_id::TEXT, NEW.card_id::TEXT, NEW.change_set_id
+		WHERE OLD.card_id IS NOT DISTINCT FROM NEW.card_id
+	UNION
+	-- Changed finish_id
+	SELECT NEW.inventory_id, 'finish_id', OLD.finish_id::TEXT, NEW.finish_id::TEXT, NEW.change_set_id
+		WHERE OLD.finish_id IS NOT DISTINCT FROM NEW.finish_id
+	UNION
+	-- Changed condition_id
+	SELECT NEW.inventory_id, 'condition_id', OLD.condition_id::TEXT, NEW.condition_id::TEXT, NEW.change_set_id
+		WHERE OLD.condition_id IS NOT DISTINCT FROM NEW.condition_id
+	UNION
+	-- Changed sleeve_colour_name
+	SELECT NEW.inventory_id, 'sleeve_colour_name', OLD.sleeve_colour_name, NEW.sleeve_colour_name, NEW.change_set_id
+		WHERE OLD.sleeve_colour_name IS NOT DISTINCT FROM NEW.sleeve_colour_name
+	UNION
+	-- Changed location_name
+	SELECT NEW.inventory_id, 'location_name', OLD.location_name, NEW.location_name, NEW.change_set_id
+		WHERE OLD.location_name IS NOT DISTINCT FROM NEW.location_name
+	UNION
+	-- Changed acquired_from
+	SELECT NEW.inventory_id, 'acquired_from', OLD.acquired_from, NEW.acquired_from, NEW.change_set_id
+		WHERE OLD.acquired_from IS NOT DISTINCT FROM NEW.acquired_from
+	UNION
+	-- Changed acquired_on
+	SELECT NEW.inventory_id, 'acquired_on', TO_CHAR(OLD.acquired_on, 'YYYY-MM-DD'), TO_CHAR(NEW.acquired_on, 'YYYY-MM-DD'), NEW.change_set_id
+		WHERE OLD.acquired_on IS NOT DISTINCT FROM NEW.acquired_on
+	UNION
+	-- Changed cost_gbp
+	SELECT NEW.inventory_id, 'cost_gbp', OLD.cost_gbp::TEXT, NEW.cost_gbp::TEXT, NEW.change_set_id
+		WHERE OLD.cost_gbp IS NOT DISTINCT FROM NEW.cost_gbp
+	UNION
+	-- Changed sale_price_gbp
+	SELECT NEW.inventory_id, 'sale_price_gbp', OLD.sale_price_gbp::TEXT, NEW.sale_price_gbp::TEXT, NEW.change_set_id
+		WHERE OLD.sale_price_gbp IS NOT DISTINCT FROM NEW.sale_price_gbp
+	UNION
+	-- Changed is_sold
+	SELECT NEW.inventory_id, 'is_sold', OLD.is_sold::TEXT, NEW.is_sold::TEXT, NEW.change_set_id
+		WHERE OLD.is_sold IS NOT DISTINCT FROM NEW.is_sold
+	UNION
+	-- Changed is_destroyed
+	SELECT NEW.inventory_id, 'is_destroyed', OLD.is_destroyed::TEXT, NEW.is_destroyed::TEXT, NEW.change_set_id
+		WHERE OLD.is_destroyed IS NOT DISTINCT FROM NEW.is_destroyed
+	UNION
+	-- Changed notes
+	SELECT NEW.inventory_id, 'notes', OLD.notes, NEW.notes, NEW.change_set_id
+		WHERE OLD.notes IS NOT DISTINCT FROM NEW.notes
+	UNION
+	-- Changed alterations_customisations
+	SELECT NEW.inventory_id, 'alterations_customisations', OLD.alterations_customisations, NEW.alterations_customisations, NEW.change_set_id
+		WHERE OLD.alterations_customisations IS NOT DISTINCT FROM NEW.alterations_customisations
+	UNION
+	-- Changed grading_company_name
+	SELECT NEW.inventory_id, 'grading_company_name', OLD.grading_company_name, NEW.grading_company_name, NEW.change_set_id
+		WHERE OLD.grading_company_name IS NOT DISTINCT FROM NEW.grading_company_name
+	UNION
+	-- Changed grading_score
+	SELECT NEW.inventory_id, 'grading_score', OLD.grading_score, NEW.grading_score, NEW.change_set_id
+		WHERE OLD.grading_score IS NOT DISTINCT FROM NEW.grading_score
+	UNION
+	-- Changed subgrades
+	SELECT NEW.inventory_id, 'subgrades', OLD.subgrades, NEW.subgrades, NEW.change_set_id
+		WHERE OLD.subgrades IS NOT DISTINCT FROM NEW.subgrades
+	UNION
+	-- Changed misprint_errors
+	SELECT NEW.inventory_id, 'misprint_errors', OLD.misprint_errors, NEW.misprint_errors, NEW.change_set_id
+		WHERE OLD.misprint_errors IS NOT DISTINCT FROM NEW.misprint_errors
+	UNION
+	-- Changed miscut_errors
+	SELECT NEW.inventory_id, 'miscut_errors', OLD.miscut_errors, NEW.miscut_errors, NEW.change_set_id
+		WHERE OLD.miscut_errors IS NOT DISTINCT FROM NEW.miscut_errors
+	UNION
+	-- Changed playability
+	SELECT NEW.inventory_id, 'playability', OLD.playability, NEW.playability, NEW.change_set_id
+		WHERE OLD.playability IS NOT DISTINCT FROM NEW.playability
+	UNION
+	-- Changed owner_user_id
+	SELECT NEW.inventory_id, 'owner_user_id', OLD.owner_user_id::TEXT, NEW.owner_user_id::TEXT, NEW.change_set_id
+		WHERE OLD.owner_user_id IS NOT DISTINCT FROM NEW.owner_user_id
+	UNION
+	-- Changed ownership_status_name
+	SELECT NEW.inventory_id, 'ownership_status_name', OLD.ownership_status_name, NEW.ownership_status_name, NEW.change_set_id
+		WHERE OLD.ownership_status_name IS NOT DISTINCT FROM NEW.ownership_status_name
+	UNION
+	-- Changed trading_status_name
+	SELECT NEW.inventory_id, 'trading_status_name', OLD.trading_status_name, NEW.trading_status_name, NEW.change_set_id
+		WHERE OLD.trading_status_name IS NOT DISTINCT FROM NEW.trading_status_name
+	UNION
+	-- Changed loaned_to_user_id
+	SELECT NEW.inventory_id, 'loaned_to_user_id', OLD.loaned_to_user_id::TEXT, NEW.loaned_to_user_id::TEXT, NEW.change_set_id
+		WHERE OLD.loaned_to_user_id IS NOT DISTINCT FROM NEW.loaned_to_user_id
+	UNION
+	-- Changed acquired_on
+	SELECT NEW.inventory_id, 'acquired_on', TO_CHAR(OLD.acquired_on, 'YYYY-MM-DD'), TO_CHAR(NEW.acquired_on, 'YYYY-MM-DD'), NEW.change_set_id
+		WHERE OLD.acquired_on IS NOT DISTINCT FROM NEW.acquired_on
+	UNION
+	-- Changed acquired_on
+	SELECT NEW.inventory_id, 'acquired_on', TO_CHAR(OLD.acquired_on, 'YYYY-MM-DD'), TO_CHAR(NEW.acquired_on, 'YYYY-MM-DD'), NEW.change_set_id
+		WHERE OLD.acquired_on IS NOT DISTINCT FROM NEW.acquired_on
+	UNION
+	-- Changed provenance
+	SELECT NEW.inventory_id, 'provenance', OLD.provenance, NEW.provenance, NEW.change_set_id
+		WHERE OLD.provenance IS NOT DISTINCT FROM NEW.provenance
+	UNION
+	-- Changed signed_by_names
+	SELECT NEW.inventory_id, 'signed_by_names', OLD.signed_by_names, NEW.signed_by_names, NEW.change_set_id
+		WHERE OLD.signed_by_names IS NOT DISTINCT FROM NEW.signed_by_names
+	UNION
+	-- Changed signature_condition_name
+	SELECT NEW.inventory_id, 'signature_condition_name', OLD.signature_condition_name, NEW.signature_condition_name, NEW.change_set_id
+		WHERE OLD.signature_condition_name IS NOT DISTINCT FROM NEW.signature_condition_name
+	UNION
+	-- Changed token_rear_side_card_id
+	SELECT NEW.inventory_id, 'token_rear_side_card_id', OLD.token_rear_side_card_id::TEXT, NEW.token_rear_side_card_id::TEXT, NEW.change_set_id
+		WHERE OLD.token_rear_side_card_id IS NOT DISTINCT FROM NEW.token_rear_side_card_id
+	UNION
+	-- Changed front_name
+	SELECT NEW.inventory_id, 'front_name', OLD.front_name, NEW.front_name, NEW.change_set_id
+		WHERE OLD.front_name IS NOT DISTINCT FROM NEW.front_name
+	UNION
+	-- Changed rear_name
+	SELECT NEW.inventory_id, 'rear_name', OLD.rear_name, NEW.rear_name, NEW.change_set_id
+		WHERE OLD.rear_name IS NOT DISTINCT FROM NEW.rear_name
+	UNION
+	-- Changed display_order
+	SELECT NEW.inventory_id, 'display_order', OLD.display_order::TEXT, NEW.display_order::TEXT, NEW.change_set_id
+		WHERE OLD.display_order IS NOT DISTINCT FROM NEW.display_order
+	UNION
+	-- Changed active
+	SELECT NEW.inventory_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Inventory
+    BEFORE INSERT ON tcg.public.TCG_MTG_Inventory
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Inventory()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Inventory
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Inventory
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Inventory()
+;

static/PostgreSQL/31196_tri_TCG_MTG_Deck_Commander_Bracket.sql

@@ -0,0 +1,80 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Deck_Commander_Bracket()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Deck_Commander_Bracket()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Deck_Commander_Bracket_Audit (
+		  commander_bracket_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed name
+	SELECT NEW.commander_bracket_id, 'name', OLD.name::TEXT, NEW.name::TEXT, NEW.change_set_id
+		WHERE OLD.name IS NOT DISTINCT FROM NEW.name
+	UNION
+	-- Changed description
+	SELECT NEW.commander_bracket_id, 'description', OLD.description::TEXT, NEW.description::TEXT, NEW.change_set_id
+		WHERE OLD.description IS NOT DISTINCT FROM NEW.description
+	UNION
+	-- Changed display_order
+	SELECT NEW.commander_bracket_id, 'display_order', OLD.display_order::TEXT, NEW.display_order::TEXT, NEW.change_set_id
+		WHERE OLD.display_order IS NOT DISTINCT FROM NEW.display_order
+	UNION
+	-- Changed active
+	SELECT NEW.commander_bracket_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Deck_Commander_Bracket
+    BEFORE INSERT ON tcg.public.TCG_MTG_Deck_Commander_Bracket
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Deck_Commander_Bracket()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Deck_Commander_Bracket
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Deck_Commander_Bracket
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Deck_Commander_Bracket()
+;

static/PostgreSQL/31200_tri_TCG_MTG_Deck.sql

@@ -0,0 +1,80 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Deck()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Deck()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Deck_Audit (
+		  deck_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed name
+	SELECT NEW.deck_id, 'name', OLD.name::TEXT, NEW.name::TEXT, NEW.change_set_id
+		WHERE OLD.name IS NOT DISTINCT FROM NEW.name
+	UNION
+	-- Changed is_commander
+	SELECT NEW.deck_id, 'is_commander', OLD.is_commander::TEXT, NEW.is_commander::TEXT, NEW.change_set_id
+		WHERE OLD.is_commander IS NOT DISTINCT FROM NEW.is_commander
+	UNION
+	-- Changed commander_bracket_id
+	SELECT NEW.deck_id, 'commander_bracket_id', OLD.commander_bracket_id::TEXT, NEW.commander_bracket_id::TEXT, NEW.change_set_id
+		WHERE OLD.commander_bracket_id IS NOT DISTINCT FROM NEW.commander_bracket_id
+	UNION
+	-- Changed active
+	SELECT NEW.deck_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Deck
+    BEFORE INSERT ON tcg.public.TCG_MTG_Deck
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Deck()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Deck
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Deck
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Deck()
+;

static/PostgreSQL/31204_tri_TCG_MTG_Deck_Inventory_Link.sql

@@ -0,0 +1,80 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Deck_Inventory_Link()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Deck_Inventory_Link()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Deck_Inventory_Link_Audit (
+		  link_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed deck_id
+	SELECT NEW.link_id, 'deck_id', OLD.deck_id::TEXT, NEW.deck_id::TEXT, NEW.change_set_id
+		WHERE OLD.deck_id IS NOT DISTINCT FROM NEW.deck_id
+	UNION
+	-- Changed inventory_id
+	SELECT NEW.link_id, 'inventory_id', OLD.inventory_id::TEXT, NEW.inventory_id::TEXT, NEW.change_set_id
+		WHERE OLD.inventory_id IS NOT DISTINCT FROM NEW.inventory_id
+	UNION
+	-- Changed display_order
+	SELECT NEW.link_id, 'display_order', OLD.display_order::TEXT, NEW.display_order::TEXT, NEW.change_set_id
+		WHERE OLD.display_order IS NOT DISTINCT FROM NEW.display_order
+	UNION
+	-- Changed active
+	SELECT NEW.link_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Deck_Inventory_Link
+    BEFORE INSERT ON tcg.public.TCG_MTG_Deck_Inventory_Link
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Deck_Inventory_Link()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Deck_Inventory_Link
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Deck_Inventory_Link
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Deck_Inventory_Link()
+;

static/PostgreSQL/31208_tri_TCG_MTG_Game.sql

@@ -0,0 +1,100 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Game()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Game()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Game_Audit (
+		  game_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed notes
+	SELECT NEW.game_id, 'notes', OLD.notes::TEXT, NEW.notes::TEXT, NEW.change_set_id
+		WHERE OLD.notes IS NOT DISTINCT FROM NEW.notes
+	UNION
+	-- Changed is_commander
+	SELECT NEW.game_id, 'is_commander', OLD.is_commander::TEXT, NEW.is_commander::TEXT, NEW.change_set_id
+		WHERE OLD.is_commander IS NOT DISTINCT FROM NEW.is_commander
+	UNION
+	-- Changed is_draft
+	SELECT NEW.game_id, 'is_draft', OLD.is_draft::TEXT, NEW.is_draft::TEXT, NEW.change_set_id
+		WHERE OLD.is_draft IS NOT DISTINCT FROM NEW.is_draft
+	UNION
+	-- Changed is_sealed
+	SELECT NEW.game_id, 'is_sealed', OLD.is_sealed::TEXT, NEW.is_sealed::TEXT, NEW.change_set_id
+		WHERE OLD.is_sealed IS NOT DISTINCT FROM NEW.is_sealed
+	UNION
+	-- Changed location_name
+	SELECT NEW.game_id, 'location_name', OLD.location_name, NEW.location_name, NEW.change_set_id
+		WHERE OLD.location_name IS NOT DISTINCT FROM NEW.location_name
+	UNION
+	-- Changed start_on
+	SELECT NEW.game_id, 'start_on', OLD.start_on::TEXT, NEW.start_on::TEXT, NEW.change_set_id
+		WHERE OLD.start_on IS NOT DISTINCT FROM NEW.start_on
+	UNION
+	-- Changed end_on
+	SELECT NEW.game_id, 'end_on', OLD.end_on::TEXT, NEW.end_on::TEXT, NEW.change_set_id
+		WHERE OLD.end_on IS NOT DISTINCT FROM NEW.end_on
+	UNION
+	-- Changed starting_life
+	SELECT NEW.game_id, 'starting_life', OLD.starting_life::TEXT, NEW.starting_life::TEXT, NEW.change_set_id
+		WHERE OLD.starting_life IS NOT DISTINCT FROM NEW.starting_life
+	UNION
+	-- Changed active
+	SELECT NEW.game_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Game
+    BEFORE INSERT ON tcg.public.TCG_MTG_Game
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Game()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Game
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Game
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Game()
+;

static/PostgreSQL/31212_tri_TCG_MTG_Game_Player.sql

@@ -0,0 +1,92 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Game_Player()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Game_Player()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Game_Player_Audit (
+		  player_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed game_id
+	SELECT NEW.player_id, 'game_id', OLD.game_id::TEXT, NEW.game_id::TEXT, NEW.change_set_id
+		WHERE OLD.game_id IS NOT DISTINCT FROM NEW.game_id
+	UNION
+	-- Changed user_id
+	SELECT NEW.player_id, 'user_id', OLD.user_id::TEXT, NEW.user_id::TEXT, NEW.change_set_id
+		WHERE OLD.user_id IS NOT DISTINCT FROM NEW.user_id
+	UNION
+	-- Changed deck_id
+	SELECT NEW.player_id, 'deck_id', OLD.deck_id::TEXT, NEW.deck_id::TEXT, NEW.change_set_id
+		WHERE OLD.deck_id IS NOT DISTINCT FROM NEW.deck_id
+	UNION
+	-- Changed name
+	SELECT NEW.player_id, 'name', OLD.name, NEW.name, NEW.change_set_id
+		WHERE OLD.name IS NOT DISTINCT FROM NEW.name
+	UNION
+	-- Changed notes
+	SELECT NEW.player_id, 'notes', OLD.notes, NEW.notes, NEW.change_set_id
+		WHERE OLD.notes IS NOT DISTINCT FROM NEW.notes
+	UNION
+	-- Changed display_order
+	SELECT NEW.player_id, 'display_order', OLD.display_order::TEXT, NEW.display_order::TEXT, NEW.change_set_id
+		WHERE OLD.display_order IS NOT DISTINCT FROM NEW.display_order
+	UNION
+	-- Changed active
+	SELECT NEW.player_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Game_Player
+    BEFORE INSERT ON tcg.public.TCG_MTG_Game_Player
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Game_Player()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Game_Player
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Game_Player
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Game_Player()
+;

static/PostgreSQL/31216_tri_TCG_MTG_Game_Round.sql

@@ -0,0 +1,80 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Game_Round()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Game_Round()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Game_Round_Audit (
+		  round_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed game_id
+	SELECT NEW.round_id, 'game_id', OLD.game_id::TEXT, NEW.game_id::TEXT, NEW.change_set_id
+		WHERE OLD.game_id IS NOT DISTINCT FROM NEW.game_id
+    UNION
+	-- Changed notes
+	SELECT NEW.round_id, 'notes', OLD.notes::TEXT, NEW.notes::TEXT, NEW.change_set_id
+		WHERE OLD.notes IS NOT DISTINCT FROM NEW.notes
+	UNION
+	-- Changed display_order
+	SELECT NEW.round_id, 'display_order', OLD.display_order::TEXT, NEW.display_order::TEXT, NEW.change_set_id
+		WHERE OLD.display_order IS NOT DISTINCT FROM NEW.display_order
+    UNION
+	-- Changed active
+	SELECT NEW.round_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Game_Round
+    BEFORE INSERT ON tcg.public.TCG_MTG_Game_Round
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Game_Round()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Game_Round
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Game_Round
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Game_Round()
+;

static/PostgreSQL/31220_tri_TCG_MTG_Game_Round_Player_Damage.sql

@@ -0,0 +1,92 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Game_Round_Player_Damage()
+RETURNS TRIGGER AS $$
+DECLARE
+    r_change_set RECORD;
+BEGIN
+    NEW.created_on = COALESCE(NEW.created_on, CURRENT_TIMESTAMP);
+    NEW.updated_last_on = COALESCE(NEW.updated_last_on, CURRENT_TIMESTAMP);
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+
+    SELECT *
+    INTO r_change_set
+    FROM tcg.public.TCG_Change_Set CHANGE_SET
+    WHERE NEW.change_set_id = CHANGE_SET.change_set_id
+    ;
+
+    IF FOUND THEN
+        NEW.created_by_user_id := COALESCE(NEW.created_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.updated_last_by_user_id := COALESCE(NEW.updated_last_by_user_id, r_change_set.updated_last_by_user_id);
+        NEW.created_on := COALESCE(NEW.created_on, r_change_set.updated_last_on);
+    ELSE
+        RAISE EXCEPTION 'Change Set % not found.', NEW.change_set_id;
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Game_Round_Player_Damage()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Game_Round_Player_Damage_Audit (
+		  damage_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed round_id
+	SELECT NEW.damage_id, 'round_id', OLD.round_id::TEXT, NEW.round_id::TEXT, NEW.change_set_id
+		WHERE OLD.round_id IS NOT DISTINCT FROM NEW.round_id
+	UNION
+	-- Changed player_id
+	SELECT NEW.damage_id, 'player_id', OLD.player_id::TEXT, NEW.player_id::TEXT, NEW.change_set_id
+		WHERE OLD.player_id IS NOT DISTINCT FROM NEW.player_id
+	UNION
+	-- Changed received_from_commander_player_id
+	SELECT NEW.damage_id, 'received_from_commander_player_id', OLD.received_from_commander_player_id::TEXT, NEW.received_from_commander_player_id::TEXT, NEW.change_set_id
+		WHERE OLD.received_from_commander_player_id IS NOT DISTINCT FROM NEW.received_from_commander_player_id
+	UNION
+	-- Changed health_change
+	SELECT NEW.damage_id, 'health_change', OLD.health_change::TEXT, NEW.health_change::TEXT, NEW.change_set_id
+		WHERE OLD.health_change IS NOT DISTINCT FROM NEW.health_change
+	UNION
+	-- Changed commander_deaths
+	SELECT NEW.damage_id, 'commander_deaths', OLD.commander_deaths::TEXT, NEW.commander_deaths::TEXT, NEW.change_set_id
+		WHERE OLD.commander_deaths IS NOT DISTINCT FROM NEW.commander_deaths
+	UNION
+	-- Changed is_eliminated
+	SELECT NEW.damage_id, 'is_eliminated', OLD.is_eliminated::TEXT, NEW.is_eliminated::TEXT, NEW.change_set_id
+		WHERE OLD.is_eliminated IS NOT DISTINCT FROM NEW.is_eliminated
+	UNION
+	-- Changed active
+	SELECT NEW.damage_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Game_Round_Player_Damage
+    BEFORE INSERT ON tcg.public.TCG_MTG_Game_Round_Player_Damage
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Game_Round_Player_Damage()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Game_Round_Player_Damage
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Game_Round_Player_Damage
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Game_Round_Player_Damage()
+;

static/PostgreSQL/70504_fn_TCG_User_Get_Many.sql

@@ -0,0 +1,100 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_TCG_User_Get_Many (
+      a_get_all_user BOOLEAN
+    , a_get_inactive_user BOOLEAN
+	, a_user_ids TEXT
+    , a_require_all_id_filters_met BOOLEAN
+    , a_require_any_id_filters_met BOOLEAN
+)
+RETURNS TABLE (
+      user_id INT
+    , user_auth0_id VARCHAR(200)
+    , firstname TEXT
+    , surname TEXT
+    , email VARCHAR(256)
+    , is_email_verified BOOLEAN
+    , is_super_user BOOLEAN
+    , active BOOLEAN
+    , created_on TIMESTAMP
+    , created_by_user_id INT
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+    , change_set_id INT
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    v_get_all_user BOOLEAN;
+    v_get_inactive_user BOOLEAN;
+    v_require_all_id_filters_met BOOLEAN;
+    v_require_any_id_filters_met BOOLEAN;
+	v_user_ids TEXT;
+BEGIN
+	v_get_all_user := COALESCE(a_get_all_user, FALSE);
+    v_get_inactive_user := COALESCE(a_get_inactive_user, FALSE);
+	v_user_ids := TRIM(COALESCE(a_user_ids, ''));
+    v_require_all_id_filters_met := COALESCE(a_require_all_id_filters_met, FALSE);
+    v_require_any_id_filters_met := COALESCE(a_require_any_id_filters_met, FALSE);
+	
+	-- Outputs
+    RETURN QUERY SELECT
+          TCG_USER.user_id
+        , TCG_USER.user_auth0_id
+        , TCG_USER.firstname
+        , TCG_USER.surname
+        , TCG_USER.email
+        , TCG_USER.is_email_verified
+        , TCG_USER.is_super_user
+        , TCG_USER.active
+        , TCG_USER.created_on
+        , TCG_USER.created_by_user_id
+        , TCG_USER.updated_last_on
+        , TCG_USER.updated_last_by_user_id
+        , TCG_USER.change_set_id
+    FROM tcg.public.TCG_User TCG_USER
+    WHERE
+            (
+                (
+                    NOT v_require_all_id_filters_met
+                AND NOT v_require_any_id_filters_met
+            )
+            OR  (
+                    v_require_all_id_filters_met
+                AND (
+                        v_get_all_user
+                    OR  TCG_USER.user_id = ANY(string_to_array(v_user_ids, ',')::INT[])
+                )
+            )
+            OR  (
+                    NOT v_require_all_id_filters_met
+                AND v_require_any_id_filters_met
+                AND (
+                        v_get_all_user
+                    OR  TCG_USER.user_id = ANY(string_to_array(v_user_ids, ',')::INT[])
+                )
+            )
+        )
+        AND (
+                v_get_inactive_user
+            OR  TCG_USER.active
+        )
+	ORDER BY TCG_USER.firstname, TCG_USER.surname, TCG_USER.email
+    ;
+END;
+$$;
+
+
+SELECT *
+FROM tcg.public.FN_TCG_User_Get_Many (
+      a_get_all_user := TRUE
+    , a_get_inactive_user := FALSE
+    , a_user_ids := ''
+    , a_require_all_id_filters_met := TRUE 
+    , a_require_any_id_filters_met := FALSE 
+)
+;
+
+
+SELECT *
+FROM tcg.public.TCG_User
+;

static/PostgreSQL/70505_usp_TCG_User_Login.sql

@@ -0,0 +1,254 @@
+
+CREATE OR REPLACE PROCEDURE tcg.public.USP_TCG_User_Login (
+      a_user_auth0_id TEXT
+    , a_email TEXT
+    , a_guid UUID
+    , a_is_email_verified BOOLEAN
+	, OUT o_success BOOLEAN
+    , OUT o_user_id INT
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+	v_bad_data_error_type_id INT;
+	v_bot_user_id INT;
+	v_change_set_id INT;
+    v_email TEXT;
+	-- v_error_message TEXT;
+	v_guid UUID;
+    v_is_email_verified BOOLEAN;
+	v_time_start TIMESTAMP;
+    v_user_auth0_id TEXT;
+	v_warning_error_type_id INT;
+BEGIN
+	v_user_auth0_id := TRIM(COALESCE(a_user_auth0_id, ''));
+    v_email := TRIM(COALESCE(a_email, ''));
+    v_is_email_verified := COALESCE(a_is_email_verified, FALSE);
+
+	v_bad_data_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'BAD_DATA' LIMIT 1);
+	v_warning_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'WARNING' LIMIT 1);
+	v_bot_user_id := 6;
+	v_time_start := CURRENT_TIMESTAMP;
+
+    o_success := FALSE;
+	
+	DROP TABLE IF EXISTS Temp_User_Save_User;
+	DROP TABLE IF EXISTS Temp_User_Save_Error;
+    
+    CREATE TABLE Temp_User_Save_User (
+          user_id INT NOT NULL
+        , user_auth0_id TEXT
+        , firstname TEXT
+        , surname TEXT
+        , email TEXT
+        , is_email_verified BOOLEAN
+        , is_super_user BOOLEAN
+        , active BOOLEAN
+        , created_on TIMESTAMP
+        , created_by_user_id INT
+        , updated_last_on TIMESTAMP
+        , updated_last_by_user_id INT
+        , change_set_id INT
+    );
+
+	CREATE TEMP TABLE Temp_User_Save_Error (
+		  temp_id INT GENERATED ALWAYS AS IDENTITY
+		, error_type_id INT
+		, message TEXT
+	);
+
+    IF v_user_auth0_id = '' THEN
+        INSERT INTO Temp_User_Save_Error (
+			  error_type_id
+			, message
+		)
+		VALUES (
+			  v_bad_data_error_type_id
+			, 'User Auth0 ID required.'
+		);
+    END IF;
+	
+	INSERT INTO Temp_User_Save_User (
+          user_id
+        , user_auth0_id
+        , firstname
+        , surname
+        , email
+        , is_email_verified
+        , is_super_user
+        , active
+        , created_on
+        , created_by_user_id
+        , updated_last_on
+        , updated_last_by_user_id
+        , change_set_id
+    )
+	SELECT
+          TCG_USER.user_id
+        , TCG_USER.user_auth0_id
+        , TCG_USER.firstname
+        , TCG_USER.surname
+        , TCG_USER.email
+        , TCG_USER.is_email_verified
+        , TCG_USER.is_super_user
+        , COALESCE(TCG_USER.active, TRUE)
+        , COALESCE(TCG_USER.created_on, v_time_start) -- created_on
+        , COALESCE(TCG_USER.created_by_user_id, v_bot_user_id) -- created_by_user_id
+        , COALESCE(TCG_USER.updated_last_on, v_time_start) -- updated_last_on
+        , COALESCE(TCG_USER.updated_last_by_user_id, v_bot_user_id) -- updated_last_by_user_id
+        , TCG_USER.change_set_id
+	FROM tcg.public.TCG_User TCG_USER
+	WHERE TCG_USER.user_auth0_id = v_user_auth0_id
+	;
+
+	-- Outputs
+	-- Change Set
+	INSERT INTO tcg.public.TCG_Change_Set (
+		  comment
+		, updated_last_by_user_id
+	)
+	VALUES (
+		  'Save User'
+		, v_bot_user_id
+	)
+	RETURNING change_set_id INTO v_change_set_id
+	;
+	
+	IF NOT EXISTS (SELECT * FROM Temp_User_Save_Error T_ERROR WHERE T_ERROR.error_type_id <> v_warning_error_type_id LIMIT 1) THEN
+		
+        IF NOT EXISTS (SELECT * FROM Temp_User_Save_User T_USER LIMIT 1) THEN
+            -- RAISE EXCEPTION 'Valid User Auth0 ID required.';
+
+            -- New User
+            INSERT INTO tcg.public.TCG_User (
+                  user_auth0_id
+                , firstname
+                , surname
+                , email
+                , is_email_verified
+                , is_super_user
+                , active
+                , created_on
+                , created_by_user_id
+                , updated_last_on
+                , updated_last_by_user_id
+                , change_set_id
+            )
+            VALUES (
+                  v_user_auth0_id -- user_auth0_id
+                , '' -- firstname
+                , '' -- surname
+                , v_email -- email
+                , v_is_email_verified -- is_email_verified
+                , FALSE -- is_super_user
+                , TRUE -- active
+                , v_time_start -- created_on
+                , v_bot_user_id -- created_by_user_id
+                , v_time_start -- updated_last_on
+                , v_bot_user_id -- updated_last_by_user_id
+                , v_change_set_id -- change_set_id
+            );
+
+        END IF;
+	ELSE
+		-- Error
+		INSERT INTO tcg.public.Error (
+			  guid
+			, error_type_id
+			, message
+			, display_order
+			, created_on
+			, created_by_user_id
+			, updated_last_on
+			, updated_last_by_user_id
+			, change_set_id
+		)
+		SELECT
+			  a_guid
+			, T_ERROR.error_type_id
+			, T_ERROR.message
+			, T_ERROR.temp_id
+			, v_time_start
+			, a_user_id
+			, v_time_start
+			, a_user_id
+			, v_change_set_id
+		FROM Temp_User_Save_Error T_ERROR
+		LEFT JOIN tcg.public.Error_Type ERROR_TYPE ON T_ERROR.error_type_id = ERROR_TYPE.error_type_id
+		ORDER BY T_ERROR.temp_id
+		;
+	END IF;
+
+    COMMIT;
+	
+    o_user_id := (
+        SELECT TCG_USER.user_id
+        FROM tcg.public.TCG_User TCG_USER
+        WHERE TCG_USER.user_auth0_id = v_user_auth0_id
+        ORDER BY TCG_USER.user_id DESC
+        LIMIT 1
+    );
+
+	o_success := (
+            NOT EXISTS (
+            SELECT *
+            FROM Temp_User_Save_Error T_ERROR
+            WHERE T_ERROR.error_type_id <> v_warning_error_type_id
+            LIMIT 1
+        )
+        AND o_user_id IS NOT NULL
+    );
+	
+	DROP TABLE IF EXISTS Temp_User_Save_User;
+	DROP TABLE IF EXISTS Temp_User_Save_Error;
+END;
+$$;
+
+
+-- Call it with:
+DO $$
+DECLARE
+    v_user_auth0_id TEXT := 'auth0|6582b95c895d09a70ba10fef';
+    v_email TEXT := 'edward.middletonsmith@gmail.com';
+	v_guid UUID = '5555092c-d8b6-45b6-9ae4-f29a554d8a16';
+    v_is_email_verified BOOLEAN := False;
+	
+    v_success BOOLEAN := False;
+    v_user_id INT = NULL;
+BEGIN
+	-- v_guid := gen_random_uuid();
+
+    CALL tcg.public.USP_TCG_User_Login (
+		  v_user_auth0_id -- a_user_auth0_id
+		, v_email -- a_email
+		, v_guid -- a_guid
+		, v_is_email_verified -- a_is_email_verified
+		, v_success -- o_success
+        , v_user_id -- o_user_id
+	);
+    RAISE NOTICE 'Success: %\nUser ID: %', CASE WHEN v_success THEN 'TRUE' ELSE 'FALSE' END, CAST(v_user_id AS VARCHAR);
+END;
+$$;
+
+SELECT *
+-- DELETE
+FROM tcg.public.Error ERROR
+LEFT JOIN tcg.public.Error_Type ERROR_TYPE ON ERROR.error_type_id = ERROR_TYPE.error_type_id
+;
+SELECT *
+FROM tcg.public.Error_Type ERROR_TYPE
+;
+SELECT *
+FROM tcg.public.TCG_Change_Set CHANGE_SET
+ORDER BY CHANGE_SET.change_set_id  DESC
+;
+/*
+SELECT *
+FROM tcg.public.TCG_MTG_Game
+;
+*/
+SELECT *
+-- DELETE
+FROM tcg.public.TCG_User TCG_USER
+ORDER BY TCG_USER.user_id DESC
+;

static/PostgreSQL/70514_fn_TCG_Error_Get_Many.sql

@@ -0,0 +1,79 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_Error_Get_Many (
+      a_guid UUID
+)
+RETURNS TABLE (
+      error_id INT
+	, guid UUID
+    , error_type_id INT
+    , error_type_code TEXT
+    , error_type_name TEXT
+    , message TEXT
+    , display_order INT
+    , active BOOLEAN
+    , created_on TIMESTAMP
+    , created_by_user_id INT
+    , updated_last_on TIMESTAMP
+    , updated_last_by_user_id INT
+    , change_set_id INT
+)
+LANGUAGE plpgsql
+AS $$
+BEGIN
+    IF a_guid IS NULL THEN
+        RAISE EXCEPTION 'GUID required.';
+    END IF;
+
+	-- Outputs
+    RETURN QUERY SELECT
+          ERROR.error_id
+		, ERROR.guid AS guid
+        , ERROR.error_type_id
+        , ERROR_TYPE.code AS error_type_code
+        , ERROR_TYPE.name AS error_type_name
+        , ERROR.message
+        , ERROR.display_order
+        , ERROR.active
+        , ERROR.created_on
+        , ERROR.created_by_user_id
+        , ERROR.updated_last_on
+        , ERROR.updated_last_by_user_id
+        , ERROR.change_set_id
+    FROM tcg.public.Error ERROR
+    LEFT JOIN tcg.public.Error_Type ERROR_TYPE ON ERROR.error_type_id = ERROR_TYPE.error_type_id
+    WHERE ERROR.guid = a_guid
+    ORDER BY COALESCE(ERROR.display_order, ERROR.error_id)
+    ;
+END;
+$$;
+
+
+
+-- Call it with:
+SELECT *
+FROM tcg.public.FN_Error_Get_Many (
+      a_guid := '9a117327-63cc-49a7-88e7-54176f30be84'::UUID
+)
+;
+
+/*
+
+
+-- Call it with:
+DO $$
+DECLARE
+    v_guid UUID := CAST('9a117327-63cc-49a7-88e7-54176f30be84' AS UUID);
+BEGIN
+
+	
+	SELECT *
+	FROM tcg.public.FN_Error_Get_Many (
+	      a_guid := v_guid
+	)
+	;
+END;
+$$;
+SELECT *
+FROM tcg.public.Error
+;
+*/

static/PostgreSQL/70515_usp_Error_Clear.sql

@@ -0,0 +1,42 @@
+
+CREATE OR REPLACE PROCEDURE tcg.public.USP_Error_Clear (
+      a_guid UUID
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+	v_guid UUID;
+BEGIN
+
+	v_guid := a_guid::UUID;
+
+    DELETE
+    FROM tcg.public.Error ERROR
+    WHERE ERROR.guid = v_guid
+    ;
+
+    COMMIT;
+	
+END;
+$$;
+
+
+-- Call it with:
+DO $$
+DECLARE
+    v_guid UUID := CAST('1d7a1ade-daf4-4736-946e-a3e8a2097c07' AS UUID);
+BEGIN
+	-- v_guid := gen_random_uuid();
+
+    CALL tcg.public.USP_Error_Clear (
+		  a_guid := v_guid
+	);
+
+END;
+$$;
+
+SELECT *
+-- DELETE
+FROM tcg.public.Error ERROR
+LEFT JOIN tcg.public.Error_Type ERROR_TYPE ON ERROR.error_type_id = ERROR_TYPE.error_type_id
+;

static/PostgreSQL/71200_fn_TCG_MTG_Deck_Get_Many.sql

@@ -0,0 +1,141 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_TCG_MTG_Deck_Get_Many (
+      a_get_all_deck BOOLEAN
+    , a_get_inactive_deck BOOLEAN
+	, a_deck_ids TEXT
+	, a_deck_names TEXT
+	, a_commander_bracket_ids TEXT
+	, a_include_commander_option BOOLEAN
+    , a_require_all_id_filters_met BOOLEAN
+    , a_require_any_id_filters_met BOOLEAN
+    , a_require_all_non_id_filters_met BOOLEAN
+    , a_require_any_non_id_filters_met BOOLEAN
+)
+RETURNS TABLE (
+      deck_id INT
+    , name TEXT
+    , is_commander BOOLEAN
+    , commander_bracket_id INT
+    , active BOOLEAN
+    , created_on TIMESTAMP
+    , created_by_user_id INT
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+    , change_set_id INT
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    v_get_all_deck BOOLEAN;
+    v_get_inactive_deck BOOLEAN;
+	v_deck_ids TEXT;
+	v_deck_names TEXT;
+	v_include_commander_option BOOLEAN;
+    v_require_all_id_filters_met BOOLEAN;
+    v_require_any_id_filters_met BOOLEAN;
+    v_require_all_non_id_filters_met BOOLEAN;
+    v_require_any_non_id_filters_met BOOLEAN;
+BEGIN
+	v_get_all_deck := COALESCE(a_get_all_deck, FALSE);
+    v_get_inactive_deck := COALESCE(a_get_inactive_deck, FALSE);
+	v_deck_ids := TRIM(COALESCE(a_deck_ids, ''));
+	v_deck_names := TRIM(COALESCE(a_deck_names, ''));
+    v_include_commander_option := COALESCE(a_include_commander_option, TRUE);
+    v_require_all_id_filters_met := COALESCE(a_require_all_id_filters_met, FALSE);
+    v_require_any_id_filters_met := COALESCE(a_require_any_id_filters_met, FALSE);
+    v_require_all_non_id_filters_met := COALESCE(a_require_all_non_id_filters_met, FALSE);
+    v_require_any_non_id_filters_met := COALESCE(a_require_any_non_id_filters_met, FALSE);
+	
+	-- Outputs
+    RETURN QUERY SELECT
+          DECK.deck_id
+        , DECK.name
+        , DECK.is_commander
+        , DECK.commander_bracket_id
+        , DECK.active
+        , DECK.created_on
+        , DECK.created_by_user_id
+        , DECK.updated_last_on
+        , DECK.updated_last_by_user_id
+        , DECK.change_set_id
+    FROM tcg.public.TCG_MTG_Deck DECK
+    WHERE
+            (
+                (
+                    NOT v_require_all_id_filters_met
+                AND NOT v_require_any_id_filters_met
+            )
+            OR  (
+                    v_require_all_id_filters_met
+                AND (
+                        v_get_all_deck
+                    OR  DECK.deck_id = ANY(string_to_array(v_deck_ids, ',')::INT[])
+                )
+            )
+            OR  (
+                    NOT v_require_all_id_filters_met
+                AND v_require_any_id_filters_met
+                AND (
+                        v_get_all_deck
+                    OR  DECK.deck_id = ANY(string_to_array(v_deck_ids, ',')::INT[])
+                )
+            )
+        )
+        AND (
+                (
+                    NOT v_require_all_non_id_filters_met
+                AND NOT v_require_any_non_id_filters_met
+            )
+            OR  (
+                    v_require_all_non_id_filters_met
+                AND (
+                        v_get_all_deck
+                    OR  DECK.name LIKE ANY (SELECT '%' || TRIM(s) || '%' FROM unnest(string_to_array(v_deck_names, ',')) s)
+                )
+            )
+            OR  (
+                    NOT v_require_all_non_id_filters_met
+                AND v_require_any_non_id_filters_met
+                AND (
+                        v_get_all_deck
+                    OR  DECK.name LIKE ANY (SELECT '%' || TRIM(s) || '%' FROM unnest(string_to_array(v_deck_names, ',')) s)
+                )
+            )
+        )
+        AND (
+				v_include_commander_option
+			OR  (
+	                NOT v_include_commander_option
+	            AND NOT DECK.is_commander
+			)
+        )
+        AND (
+                v_get_inactive_deck
+            OR  DECK.active
+        )
+	ORDER BY DECK.name
+    ;
+END;
+$$;
+
+
+SELECT *
+FROM tcg.public.FN_TCG_MTG_Deck_Get_Many (
+      a_get_all_deck := TRUE
+    , a_get_inactive_deck := FALSE
+    , a_deck_ids := CAST(NULL AS TEXT)
+    , a_deck_names := CAST(NULL AS TEXT)
+    , a_commander_bracket_ids := CAST(NULL AS TEXT)
+    , a_include_commander_option := TRUE
+    , a_require_all_id_filters_met := FALSE
+    , a_require_any_id_filters_met := FALSE
+    , a_require_all_non_id_filters_met := FALSE
+    , a_require_any_non_id_filters_met := FALSE
+)
+;
+
+SELECT *
+FROM tcg.public.TCG_MTG_Deck
+;
+
+

static/PostgreSQL/71208_fn_TCG_MTG_Game_Get_Many.sql

@@ -0,0 +1,137 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_TCG_MTG_Game_Get_Many (
+      a_get_all_game BOOLEAN
+    , a_get_inactive_game BOOLEAN
+	, a_game_ids TEXT
+    , a_get_all_user BOOLEAN
+    , a_get_inactive_user BOOLEAN
+	, a_user_ids TEXT
+    , a_require_all_id_filters_met BOOLEAN
+    , a_require_any_id_filters_met BOOLEAN
+)
+RETURNS TABLE (
+      game_id INT
+    , notes TEXT
+    , is_commander BOOLEAN
+    , is_draft BOOLEAN
+    , is_sealed BOOLEAN
+    , location_name TEXT
+    , start_on TIMESTAMP
+    , end_on TIMESTAMP
+    , active BOOLEAN
+    , created_on TIMESTAMP
+    , created_by_user_id INT
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+	-- v_bad_data_error_type_id INT;
+	-- v_warning_error_type_id INT;
+    v_get_all_game BOOLEAN;
+    v_get_inactive_game BOOLEAN;
+	v_game_ids TEXT;
+    v_get_all_user BOOLEAN;
+    v_get_inactive_user BOOLEAN;
+	v_user_ids TEXT;
+    v_require_all_id_filters_met BOOLEAN;
+    v_require_any_id_filters_met BOOLEAN;
+    -- , v_require_all_non_id_filters_met BOOLEAN
+    -- , v_require_any_non_id_filters_met BOOLEAN
+BEGIN
+	-- v_bad_data_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'BAD_DATA' LIMIT 1);
+	-- v_warning_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'WARNING' LIMIT 1);
+    v_get_all_game := COALESCE(a_get_all_game, FALSE);
+    v_get_inactive_game := COALESCE(a_get_inactive_game, FALSE);
+	v_game_ids := TRIM(COALESCE(a_game_ids, ''));
+    v_get_all_user := COALESCE(a_get_all_user, FALSE);
+    v_get_inactive_user := COALESCE(a_get_inactive_user, FALSE);
+	v_user_ids := TRIM(COALESCE(a_user_ids, ''));
+    v_require_all_id_filters_met := COALESCE(a_require_all_id_filters_met, FALSE);
+    v_require_any_id_filters_met := COALESCE(a_require_any_id_filters_met, FALSE);
+	
+	-- Outputs
+
+    RETURN QUERY SELECT
+          GAME.game_id
+        , GAME.notes
+        , GAME.is_commander
+        , GAME.is_draft
+        , GAME.is_sealed
+        , GAME.location_name
+        , GAME.start_on
+        , GAME.end_on
+        , GAME.active
+        , GAME.created_on
+        , GAME.created_by_user_id
+    FROM tcg.public.TCG_MTG_Game GAME
+    INNER JOIN tcg.public.TCG_User CREATOR_USER ON GAME.created_by_user_id = CREATOR_USER.user_id
+    WHERE
+            (
+                (
+                    NOT v_require_all_id_filters_met
+                AND NOT v_require_any_id_filters_met
+            )
+            OR  (
+                    v_require_all_id_filters_met
+                AND (
+                        v_get_all_game
+                    OR  GAME.game_id = ANY(string_to_array(v_game_ids, ',')::INT[])
+                )
+                AND (
+                        a_get_all_user
+                    OR  CREATOR_USER.user_id = ANY(string_to_array(v_user_ids, ',')::INT[])
+                )
+            )
+            OR  (
+                    NOT v_require_all_id_filters_met
+                AND v_require_any_id_filters_met
+                AND (
+                        v_get_all_game
+                    OR  GAME.game_id = ANY(string_to_array(v_game_ids, ',')::INT[])
+                )
+                AND (
+                        v_get_all_user
+                    OR  CREATOR_USER.user_id = ANY(string_to_array(v_user_ids, ',')::INT[])
+                )
+            )
+        )
+        AND (
+                v_get_inactive_game
+            OR  GAME.active
+        )
+        AND (
+                v_get_inactive_user
+            OR  CREATOR_USER.active
+        )
+	ORDER BY GAME.created_on DESC
+    ;
+END;
+$$;
+
+
+SELECT *
+FROM tcg.public.FN_TCG_MTG_Game_Get_Many (
+      a_get_all_game := TRUE
+    , a_get_inactive_game := FALSE
+    , a_game_ids := ''
+    , a_get_all_user := TRUE
+    , a_get_inactive_user := FALSE 
+    , a_user_ids := ''
+    , a_require_all_id_filters_met := TRUE 
+    , a_require_any_id_filters_met := FALSE 
+)
+;
+
+/*
+SELECT *
+FROM tcg.public.TCG_MTG_Game
+;
+
+SELECT *
+FROM tcg.public.TCG_User
+;
+
+SELECT *
+FROM tcg.public.TCG_MTG_Deck
+;
+*/

static/PostgreSQL/71209_usp_TCG_MTG_Game_Save.sql

@@ -0,0 +1,265 @@
+
+CREATE OR REPLACE PROCEDURE tcg.public.USP_TCG_MTG_Game_Save (
+      a_comment TEXT
+    , a_end_on TIMESTAMP
+	, a_game_id INT
+    , a_guid UUID
+    , a_location_name TEXT
+    , a_notes TEXT
+    , a_starting_life INT
+    , a_start_on TIMESTAMP
+    , a_user_id INT
+    , a_do_delete BOOLEAN
+    , a_is_commander BOOLEAN
+    , a_is_draft BOOLEAN
+    , a_is_sealed BOOLEAN
+	, OUT o_game_id INT
+	, OUT o_success BOOLEAN
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+	-- v_bad_data_error_type_id INT;
+	v_change_set_id INT;
+    v_comment TEXT;
+    v_do_delete BOOLEAN;
+    v_end_on TIMESTAMP;
+	v_game_id INT;
+    v_guid UUID;
+    v_is_commander BOOLEAN;
+    v_is_draft BOOLEAN;
+    v_is_new BOOLEAN;
+    v_is_sealed BOOLEAN;
+    v_location_name TEXT;
+    v_notes TEXT;
+    v_starting_life INT;
+    v_start_on TIMESTAMP;
+	v_success BOOLEAN;
+	v_time_start TIMESTAMP;
+    v_user_id INT;
+	v_warning_error_type_id INT;
+BEGIN
+    v_comment := TRIM(COALESCE(a_comment, ''));
+    v_end_on := a_end_on;
+	v_game_id := CASE WHEN COALESCE(a_game_id, 0) > 0 THEN a_game_id ELSE NULL END;
+    v_guid := a_guid;
+    v_location_name := TRIM(COALESCE(a_location_name, ''));
+    v_notes := TRIM(COALESCE(a_notes, ''));
+	v_starting_life := CASE WHEN COALESCE(a_starting_life, 0) > 0 THEN a_starting_life ELSE 40 END;
+    v_start_on := a_start_on;
+    v_user_id := CASE WHEN COALESCE(a_user_id, 0) > 0 THEN a_user_id ELSE NULL END;
+    v_do_delete := COALESCE(a_do_delete, FALSE);
+    v_is_commander := COALESCE(a_is_commander, TRUE);
+    v_is_draft := COALESCE(a_is_draft, FALSE);
+    v_is_sealed := COALESCE(a_is_sealed, FALSE);
+
+	-- v_bad_data_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'BAD_DATA' LIMIT 1);
+	v_warning_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'WARNING' LIMIT 1);
+	v_time_start := CURRENT_TIMESTAMP;
+	
+    v_is_new := CASE WHEN COALESCE(v_game_id, 0) < 1 THEN TRUE ELSE FALSE END;
+	
+	-- Outputs
+	-- Change Set
+	INSERT INTO tcg.public.TCG_Change_Set (
+		  comment
+		, updated_last_by_user_id
+	)
+	VALUES (
+		  v_comment
+		, v_user_id
+	)
+	RETURNING change_set_id INTO v_change_set_id
+	;
+	
+	INSERT INTO tcg.public.Error (
+		  guid
+		, error_type_id
+		, message
+		, display_order
+		, created_on
+		, created_by_user_id
+		, updated_last_on
+		, updated_last_by_user_id
+		, change_set_id
+	)
+	VALUES (
+		  v_guid
+		, v_warning_error_type_id
+		, CONCAT(
+			'Is New: '
+			, v_is_new::TEXT
+			, ', Game: '
+			, v_game_id::TEXT
+		)
+		, 1 -- display_order
+		, v_time_start -- created_on
+		, v_user_id -- created_by_user_id
+		, v_time_start -- updated_last_on
+		, v_user_id -- updated_last_by_user_id
+		, v_change_set_id -- change_set_id
+	);
+	
+	IF v_is_new THEN
+		INSERT INTO tcg.public.TCG_MTG_Game (
+			  notes
+		    , is_commander
+		    , is_draft
+		    , is_sealed
+		    , location_name
+            , start_on
+            , end_on
+            , starting_life
+		    , active
+			, created_on
+			, created_by_user_id
+			, updated_last_on
+			, updated_last_by_user_id
+		    , change_set_id
+		)
+		VALUES (
+			  v_notes -- notes
+		    , v_is_commander -- is_commander
+		    , v_is_draft -- is_draft
+		    , v_is_sealed -- is_sealed
+		    , v_location_name -- location_name
+            , v_start_on -- start_on
+            , v_end_on -- end_on
+            , v_starting_life -- starting_life
+            , TRUE -- active
+			, v_time_start -- created_on
+			, v_user_id -- created_by_user_id
+			, v_time_start -- updated_last_on
+			, v_user_id -- updated_last_by_user_id
+		    , v_change_set_id -- change_set_id
+        )
+	    RETURNING game_id INTO v_game_id
+		;
+
+		INSERT INTO tcg.public.TCG_MTG_Game_Round (
+			  game_id
+		    , notes
+		    , display_order
+		    , active
+			, created_on
+			, created_by_user_id
+			, updated_last_on
+			, updated_last_by_user_id
+		    , change_set_id
+		)
+		VALUES (
+			  game_id -- game_id
+            , v_notes -- notes
+		    , 1 -- display_order
+            , TRUE -- active
+			, v_time_start -- created_on
+			, v_user_id -- created_by_user_id
+			, v_time_start -- updated_last_on
+			, v_user_id -- updated_last_by_user_id
+		    , v_change_set_id -- change_set_id
+        )
+	    RETURNING game_id INTO v_game_id
+		;
+    ELSE
+		UPDATE tcg.public.TCG_MTG_Game GAME
+		SET
+			  notes = v_notes
+		    , is_commander = v_is_commander
+		    , is_draft = v_is_draft
+		    , is_sealed = v_is_sealed
+		    , location_name = v_location_name
+		    , start_on = v_start_on
+		    , end_on = v_end_on
+            , starting_life = v_starting_life
+		    , active = NOT v_do_delete
+			, updated_last_on = v_time_start
+			, updated_last_by_user_id = v_user_id
+		    , change_set_id = v_change_set_id
+		WHERE GAME.game_id = v_game_id
+		;
+	END IF;
+
+    COMMIT;
+	
+    o_game_id := v_game_id;
+	o_success := TRUE;
+END;
+$$;
+
+
+-- Call it with:
+DO $$
+DECLARE
+	v_comment TEXT := 'Edit Commander Game!';
+    v_end_on TIMESTAMP;
+	v_game_id_in INT := 7;
+    v_guid UUID;
+    v_location_name TEXT := 'Egg shell home';
+    v_notes TEXT := 'Juice in the box';
+    v_starting_life INT := 69;
+    v_start_on TIMESTAMP := '2026-02-05 11:45:00'::TIMESTAMP;
+    v_user_id INT := 3;
+    v_do_delete BOOLEAN := FALSE;
+    v_is_commander BOOLEAN := TRUE;
+    v_is_draft BOOLEAN := FALSE;
+    v_is_sealed BOOLEAN := FALSE;
+	v_game_id_out INT;
+	v_success_out BOOLEAN;
+BEGIN
+	v_guid := gen_random_uuid();
+
+    CALL tcg.public.USP_TCG_MTG_Game_Save (
+		  a_comment := v_comment -- a_comment
+        , a_end_on := v_end_on -- a_end_on
+		, a_game_id := v_game_id_in -- a_game_id
+		, a_guid := v_guid -- a_guid
+        , a_location_name := v_location_name -- a_location_name
+        , a_notes := v_notes -- a_notes
+        , a_starting_life := v_starting_life -- a_starting_life
+        , a_start_on := v_start_on -- a_start_on
+		, a_user_id := v_user_id -- a_user_id
+        , a_do_delete := v_do_delete -- a_do_delete
+        , a_is_commander := v_is_commander -- a_is_commander
+        , a_is_draft := v_is_draft -- a_is_draft
+        , a_is_sealed := v_is_sealed -- a_is_sealed
+		, o_game_id := v_game_id_out -- o_game_id
+		, o_success := v_success_out -- o_success
+	);
+    RAISE NOTICE
+		  'Game: %, Success: %, GUID: %'
+		, CAST(v_game_id_out AS VARCHAR)
+		, CAST(v_success_out AS VARCHAR)
+		, CAST(v_guid AS VARCHAR)
+	;
+END;
+$$;
+
+SELECT *
+-- DELETE
+FROM tcg.public.Error ERROR
+LEFT JOIN tcg.public.Error_Type ERROR_TYPE ON ERROR.error_type_id = ERROR_TYPE.error_type_id
+;
+/*
+SELECT *
+FROM tcg.public.Error_Type ERROR_TYPE
+;
+*/
+SELECT *
+FROM tcg.public.TCG_Change_Set CHANGE_SET
+ORDER BY CHANGE_SET.change_set_id  DESC
+;
+SELECT *
+FROM tcg.public.TCG_MTG_Game GAME
+ORDER BY GAME.game_id DESC
+;
+
+/*
+SELECT COUNT(*)
+from tcg.public.TCG_MTG_Inventory I
+;
+SELECT
+--	COUNT(*)
+	*
+from tcg.public.TCG_MTG_Inventory_Temp I_T
+;
+*/

static/PostgreSQL/71212_fn_TCG_MTG_Game_Player_Get_Many.sql

@@ -0,0 +1,171 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_TCG_MTG_Game_Player_Get_Many (
+      a_get_all_game BOOLEAN
+    , a_get_inactive_game BOOLEAN
+	, a_game_ids TEXT
+    , a_require_all_id_filters_met BOOLEAN
+    , a_require_any_id_filters_met BOOLEAN
+)
+RETURNS TABLE (
+      player_id INT
+	, game_id INT
+    , user_id INT
+    , deck_id INT
+    , name TEXT
+    , notes TEXT
+    , display_order INT
+    , active BOOLEAN
+    , created_on TIMESTAMP
+    , created_by_user_id INT
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+    , change_set_id INT
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    v_get_all_game BOOLEAN;
+    v_get_inactive_game BOOLEAN;
+	v_game_ids TEXT;
+    v_require_all_id_filters_met BOOLEAN;
+    v_require_any_id_filters_met BOOLEAN;
+BEGIN
+	v_get_all_game := COALESCE(a_get_all_game, FALSE);
+    v_get_inactive_game := COALESCE(a_get_inactive_game, FALSE);
+	v_game_ids := TRIM(COALESCE(a_game_ids, ''));
+    v_require_all_id_filters_met := COALESCE(a_require_all_id_filters_met, FALSE);
+    v_require_any_id_filters_met := COALESCE(a_require_any_id_filters_met, FALSE);
+	
+	-- Outputs
+
+    RETURN QUERY SELECT
+          PLAYER.player_id
+        , PLAYER.game_id
+    	, PLAYER.user_id
+    	, PLAYER.deck_id
+        , PLAYER.name
+        , PLAYER.notes
+        , PLAYER.display_order
+        , PLAYER.active
+        , PLAYER.created_on
+        , PLAYER.created_by_user_id
+        , PLAYER.updated_last_on
+        , PLAYER.updated_last_by_user_id
+        , PLAYER.change_set_id
+    FROM tcg.public.TCG_MTG_Game_Player PLAYER
+    INNER JOIN tcg.public.TCG_MTG_Game GAME ON PLAYER.game_id = GAME.game_id
+    WHERE
+            (
+                (
+                    NOT v_require_all_id_filters_met
+                AND NOT v_require_any_id_filters_met
+            )
+            OR  (
+                    v_require_all_id_filters_met
+                AND (
+                        v_get_all_game
+                    OR  PLAYER.game_id = ANY(string_to_array(v_game_ids, ',')::INT[])
+                )
+            )
+            OR  (
+                    NOT v_require_all_id_filters_met
+                AND v_require_any_id_filters_met
+                AND (
+                        v_get_all_game
+                    OR  PLAYER.game_id = ANY(string_to_array(v_game_ids, ',')::INT[])
+                )
+            )
+        )
+        AND (
+                v_get_inactive_game
+            OR  GAME.active
+        )
+	ORDER BY
+          GAME.created_on DESC
+        , PLAYER.display_order
+    ;
+END;
+$$;
+
+
+SELECT *
+FROM tcg.public.FN_TCG_MTG_Game_Player_Get_Many (
+      a_get_all_game := TRUE
+    , a_get_inactive_game := FALSE
+    , a_game_ids := ''
+    , a_require_all_id_filters_met := TRUE 
+    , a_require_any_id_filters_met := FALSE 
+)
+;
+
+SELECT *
+FROM tcg.public.TCG_MTG_Game
+;
+SELECT *
+FROM tcg.public.tcg_mtg_game_player_temp -- TCG_MTG_Game_Player_Temp
+;
+SELECT *
+FROM tcg.public.TCG_MTG_Game_Player
+;
+
+/*
+select *
+from information_schema.tables T
+where UPPER(T.table_name)  like '%PLAYER_T%'
+;
+
+
+
+INSERT INTO tcg.public.TCG_Change_Set (
+	comment
+	, updated_last_by_user_id
+)
+VALUES (
+	'Alter player names'
+	, 3
+);
+select *
+from tcg.public.TCG_Change_Set cs
+order by cs.change_set_id  desc
+
+WITH PLAYER_NAME AS (
+	SELECT
+		PLAYER.player_id
+		, CONCAT(
+			COALESCE(TCG_USER.firstname, 'Error')
+			, ' - '
+			, COALESCE(DECK.name, 'Error')
+		) AS name
+	FROM tcg.public.TCG_MTG_Game_Player PLAYER
+	LEFT JOIN tcg.public.TCG_User TCG_USER ON PLAYER.user_id = TCG_USER.user_id
+	LEFT JOIN tcg.public.TCG_MTG_Deck DECK ON PLAYER.deck_id = DECK.deck_id
+)
+UPDATE tcg.public.TCG_MTG_Game_Player PLAYER
+SET
+	name = PLAYER_NAME.name
+	, change_set_id = 110
+FROM PLAYER_NAME
+WHERE PLAYER.player_id = PLAYER_NAME.player_id
+AND PLAYER.player_id >= 6
+
+
+		INSERT INTO tcg.public.TCG_MTG_Game_Round (
+			  game_id
+		    , notes
+		    , display_order
+		    , active
+			, created_by_user_id
+			, updated_last_by_user_id
+		    , change_set_id
+		)
+		VALUES (
+			  11 -- game_id
+            , null -- notes
+		    , 1 -- display_order
+            , TRUE -- active
+			, 3 -- created_by_user_id
+			, 3 -- updated_last_by_user_id
+		    , 109 -- change_set_id
+        );
+*/
+

static/PostgreSQL/71213_usp_TCG_MTG_Game_Player_Save.sql

@@ -0,0 +1,661 @@
+
+CREATE OR REPLACE PROCEDURE tcg.public.USP_TCG_MTG_Game_Player_Save (
+      a_comment TEXT
+    , a_guid UUID
+    , a_user_id INT
+	, OUT o_success BOOLEAN
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+	v_bad_data_error_type_id INT;
+	v_change_set_id INT;
+	-- v_error_message TEXT;
+	v_time_start TIMESTAMP;
+	v_warning_error_type_id INT;
+BEGIN
+	v_bad_data_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'BAD_DATA' LIMIT 1);
+	v_warning_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'WARNING' LIMIT 1);
+	v_time_start := CURRENT_TIMESTAMP;
+	
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_Game;
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_User;
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_Deck;
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_Player;
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_Error;
+        
+    CREATE TABLE Temp_MTG_Player_Save_Game (
+          game_id INT NOT NULL
+        , notes TEXT
+        , is_commander BOOLEAN
+        , is_draft BOOLEAN
+        , is_sealed BOOLEAN
+        , location_name TEXT
+        , start_on TIMESTAMP
+        , end_on TIMESTAMP
+        , active BOOLEAN
+        , created_on TIMESTAMP
+        , created_by_user_id INT
+        , updated_last_on TIMESTAMP
+        , updated_last_by_user_id INT
+        , change_set_id INT
+    );
+        
+    CREATE TABLE Temp_MTG_Player_Save_User (
+          user_id INT NOT NULL
+        , user_auth0_id TEXT
+        , firstname TEXT
+        , surname TEXT
+        , email TEXT
+        , is_email_verified BOOLEAN
+        , is_super_user BOOLEAN
+        , active BOOLEAN
+        , created_on TIMESTAMP
+        , created_by_user_id INT
+        , updated_last_on TIMESTAMP
+        , updated_last_by_user_id INT
+        , change_set_id INT
+    );
+
+    CREATE TABLE Temp_MTG_Player_Save_Deck (
+          deck_id INT NOT NULL
+        , name TEXT
+        , is_commander BOOLEAN
+        , commander_bracket_id INT
+        , active BOOLEAN
+        , created_on TIMESTAMP
+        , created_by_user_id INT
+        , updated_last_on TIMESTAMP
+        , updated_last_by_user_id INT
+        , change_set_id INT
+    );
+
+    CREATE TABLE Temp_MTG_Player_Save_Player (
+          temp_id INT NOT NULL
+        , player_id INT
+        , game_id INT
+        , user_id INT
+        , deck_id INT
+        , name TEXT
+        , notes TEXT
+        , display_order INT
+        , active BOOLEAN
+        , created_on TIMESTAMP
+        , created_by_user_id INT
+        , updated_last_on TIMESTAMP
+        , updated_last_by_user_id INT
+
+        , is_new BOOLEAN
+        , error_name TEXT
+        , is_duplicate BOOLEAN
+    );
+
+	CREATE TEMP TABLE Temp_MTG_Player_Save_Error (
+		  temp_id INT GENERATED ALWAYS AS IDENTITY
+		, error_type_id INT
+		, message TEXT
+	);
+	
+	INSERT INTO Temp_MTG_Player_Save_Player (
+		  temp_id
+        , player_id
+        , game_id
+        , user_id
+        , deck_id
+        , name
+        , notes
+        , display_order
+        , active
+        , created_on
+        , created_by_user_id
+        , updated_last_on
+        , updated_last_by_user_id
+
+		, is_new
+		, error_name
+	)
+	SELECT
+		  PLAYER_T.temp_id
+        , PLAYER_T.player_id
+        , PLAYER_T.game_id
+        , PLAYER_T.user_id
+        , PLAYER_T.deck_id
+        , PLAYER_T.name
+        , PLAYER_T.notes
+        , PLAYER_T.display_order
+        , COALESCE(PLAYER_T.active, TRUE)
+        , COALESCE(PLAYER_T.created_on, v_time_start) -- created_on
+        , COALESCE(PLAYER_T.created_by_user_id, a_user_id) -- created_by_user_id
+        , COALESCE(PLAYER_T.updated_last_on, v_time_start) -- updated_last_on
+        , COALESCE(PLAYER_T.updated_last_by_user_id, a_user_id) -- updated_last_by_user_id
+
+		, CASE WHEN PLAYER.player_id IS NULL THEN TRUE ELSE FALSE END AS is_new
+		, CONCAT(
+			  'Player { id: '
+			, CAST(PLAYER_T.player_id AS VARCHAR)
+			, ', temp id: '
+			, CAST(PLAYER_T.temp_id AS VARCHAR)
+			, ', display order: '
+			, CAST(PLAYER_T.display_order AS VARCHAR)
+			, ', game id: '
+			, CAST(PLAYER_T.game_id AS VARCHAR)
+			, ', name: '
+			, PLAYER_T.name
+			, ' }'
+		) -- error_name
+	FROM tcg.public.TCG_MTG_Game_Player_Temp PLAYER_T
+	LEFT JOIN tcg.public.TCG_MTG_Game_Player PLAYER ON PLAYER_T.player_id = PLAYER.player_id
+	WHERE PLAYER_T.guid = a_guid
+	;
+	
+    INSERT INTO Temp_MTG_Player_Save_Game (
+          game_id
+        , notes
+        , is_commander
+        , is_draft
+        , is_sealed
+        , location_name
+        , start_on
+        , end_on
+        , active
+        , created_on
+        , created_by_user_id
+        , updated_last_on
+        , updated_last_by_user_id
+        , change_set_id
+    )
+	SELECT
+		  GAME.game_id
+        , GAME.notes
+        , GAME.is_commander
+        , GAME.is_draft
+        , GAME.is_sealed
+        , GAME.location_name
+        , GAME.start_on
+        , GAME.end_on
+        , GAME.active
+        , GAME.created_on
+        , GAME.created_by_user_id
+        , GAME.updated_last_on
+        , GAME.updated_last_by_user_id
+        , GAME.change_set_id
+	FROM tcg.public.TCG_MTG_Game GAME
+	INNER JOIN Temp_MTG_Player_Save_Player PLAYER ON GAME.game_id = PLAYER.game_id
+	;
+
+    INSERT INTO Temp_MTG_Player_Save_User (
+          user_id
+        , user_auth0_id
+        , firstname
+        , surname
+        , email
+        , is_email_verified
+        , is_super_user
+        , active
+        , created_on
+        , created_by_user_id
+        , updated_last_on
+        , updated_last_by_user_id
+        , change_set_id
+    )
+	SELECT
+          TCG_USER.user_id
+        , TCG_USER.user_auth0_id
+        , TCG_USER.firstname
+        , TCG_USER.surname
+        , TCG_USER.email
+        , TCG_USER.is_email_verified
+        , TCG_USER.is_super_user
+        , TCG_USER.active
+        , TCG_USER.created_on
+        , TCG_USER.created_by_user_id
+        , TCG_USER.updated_last_on
+        , TCG_USER.updated_last_by_user_id
+        , TCG_USER.change_set_id
+	FROM tcg.public.TCG_User TCG_USER
+	INNER JOIN Temp_MTG_Player_Save_Player PLAYER ON TCG_USER.user_id = PLAYER.user_id
+	;
+
+    INSERT INTO Temp_MTG_Player_Save_Deck (
+          deck_id
+        , name
+        , is_commander
+        , commander_bracket_id
+        , active
+        , created_on
+        , created_by_user_id
+        , updated_last_on
+        , updated_last_by_user_id
+        , change_set_id
+    )
+	SELECT
+          DECK.deck_id
+        , DECK.name
+        , DECK.is_commander
+        , DECK.commander_bracket_id
+        , DECK.active
+        , DECK.created_on
+        , DECK.created_by_user_id
+        , DECK.updated_last_on
+        , DECK.updated_last_by_user_id
+        , DECK.change_set_id
+	FROM tcg.public.TCG_MTG_Deck DECK
+	INNER JOIN Temp_MTG_Player_Save_Player PLAYER ON DECK.deck_id = DECK.deck_id
+	;
+
+	-- Missing fields
+	WITH Player_Missing_Field AS (
+        SELECT
+              T_PLAYER.temp_id
+            , 'game_id' AS field
+        FROM Temp_MTG_Player_Save_Player T_PLAYER
+        WHERE T_PLAYER.game_id IS NULL
+        UNION
+        SELECT
+              T_PLAYER.temp_id
+            , 'user_id' AS field
+        FROM Temp_MTG_Player_Save_Player T_PLAYER
+        WHERE T_PLAYER.user_id IS NULL
+        UNION
+        SELECT
+              T_PLAYER.temp_id
+            , 'deck_id' AS field
+        FROM Temp_MTG_Player_Save_Player T_PLAYER
+        WHERE T_PLAYER.deck_id IS NULL
+        UNION
+        SELECT
+              T_PLAYER.temp_id
+            , 'display_order' AS field
+        FROM Temp_MTG_Player_Save_Player T_PLAYER
+        WHERE T_PLAYER.display_order IS NULL
+    )
+	INSERT INTO Temp_MTG_Player_Save_Error (
+		  error_type_id
+		, message
+	)
+	SELECT
+		  v_bad_data_error_type_id -- error_type_id
+		, CONCAT(
+			'Missing mandatory field: '
+			, PLAYER_MISSING_FIELD.field
+			, ' on '
+			, T_PLAYER.error_name
+			, '.'
+		) -- message
+	FROM Temp_MTG_Player_Save_Player T_PLAYER
+	INNER JOIN Player_Missing_Field PLAYER_MISSING_FIELD ON T_PLAYER.temp_id = PLAYER_MISSING_FIELD.temp_id
+	;
+
+	-- Failed join fields
+	WITH Player_Failed_Join_Field AS (
+        SELECT
+              T_PLAYER.temp_id
+            , 'game_id' AS field
+        FROM Temp_MTG_Player_Save_Player T_PLAYER
+        LEFT JOIN Temp_MTG_Player_Save_Game T_GAME ON T_PLAYER.game_id = T_GAME.game_id
+        WHERE T_GAME.game_id IS NULL
+        UNION
+        SELECT
+              T_PLAYER.temp_id
+            , 'user_id' AS field
+        FROM Temp_MTG_Player_Save_Player T_PLAYER
+        LEFT JOIN Temp_MTG_Player_Save_User T_USER ON T_PLAYER.user_id = T_USER.user_id
+        WHERE T_USER.user_id IS NULL
+        UNION
+        SELECT
+              T_PLAYER.temp_id
+            , 'deck_id' AS field
+        FROM Temp_MTG_Player_Save_Player T_PLAYER
+        LEFT JOIN Temp_MTG_Player_Save_Deck T_DECK ON T_PLAYER.deck_id = T_DECK.deck_id
+        WHERE T_DECK.deck_id IS NULL
+    )
+	INSERT INTO Temp_MTG_Player_Save_Error (
+		  error_type_id
+		, message
+	)
+	SELECT
+		  v_bad_data_error_type_id -- error_type_id
+		, CONCAT(
+			'Failed relationship: '
+			, PLAYER_FAILED_JOIN_FIELD.field
+			, ' on '
+			, T_PLAYER.error_name
+			, '.'
+		) -- message
+	FROM Temp_MTG_Player_Save_Player T_PLAYER
+	INNER JOIN Player_Failed_Join_Field PLAYER_FAILED_JOIN_FIELD ON T_PLAYER.temp_id = PLAYER_FAILED_JOIN_FIELD.temp_id
+	;
+
+	-- Duplicate Player
+    -- By display order or deck - -add this later
+	WITH 
+		  All_Player AS (
+			SELECT
+				  T_PLAYER.temp_id
+                , T_PLAYER.game_id
+                , T_PLAYER.deck_id
+                , T_PLAYER.display_order
+                , TRUE AS is_save_record
+			FROM Temp_MTG_Player_Save_Player T_PLAYER
+            UNION
+			SELECT
+				  NULL AS temp_id
+                , PLAYER.game_id
+                , PLAYER.deck_id
+                , PLAYER.display_order
+                , FALSE AS is_save_record
+			FROM tcg.public.TCG_MTG_Game_Player PLAYER
+            LEFT JOIN Temp_MTG_Player_Save_Player T_PLAYER ON PLAYER.player_id = T_PLAYER.player_id
+            WHERE
+                    T_PLAYER.player_id IS NULL
+                AND PLAYER.active
+		)
+		, Player_Display_Order AS (
+			SELECT
+				  ALL_PLAYER.game_id
+                , ALL_PLAYER.display_order
+                , COUNT(*) AS count
+			FROM All_Player ALL_PLAYER
+            GROUP BY
+                  ALL_PLAYER.game_id
+                , ALL_PLAYER.display_order
+		)
+		, Player_Deck AS (
+			SELECT
+				  ALL_PLAYER.game_id
+                , ALL_PLAYER.deck_id
+                , COUNT(*) AS count
+			FROM All_Player ALL_PLAYER
+            GROUP BY
+                  ALL_PLAYER.game_id
+                , ALL_PLAYER.deck_id
+		)
+		, Duplicate_Player AS (
+			SELECT
+				  ALL_PLAYER.temp_id
+                , ALL_PLAYER.game_id
+                , ALL_PLAYER.deck_id
+                , ALL_PLAYER.display_order
+				-- , CASE WHEN CARD.temp_id IS NULL THEN TRUE ELSE FALSE END AS is_unique
+                , CASE WHEN PLAYER_DECK.count = 1 THEN TRUE ELSE FALSE END AS is_unique_deck
+                , CASE WHEN PLAYER_DISPLAY_ORDER.count = 1 THEN TRUE ELSE FALSE END AS is_unique_display_order
+			FROM All_Player ALL_PLAYER
+            INNER JOIN Player_Deck PLAYER_DECK ON PLAYER.deck_id = PLAYER_DECK.deck_id
+            INNER JOIN Player_Display_Order PLAYER_DISPLAY_ORDER ON PLAYER.display_order = PLAYER_DISPLAY_ORDER.display_order
+		)
+	UPDATE Temp_MTG_Player_Save_Player T_PLAYER
+	SET is_duplicate = CASE WHEN NOT ( is_unique_deck AND is_unique_display_order ) THEN TRUE ELSE FALSE END
+	FROM Duplicate_Player DUPLICATE_PLAYER
+	WHERE T_PLAYER.temp_id = DUPLICATE_PLAYER.temp_id
+	;
+	
+	IF EXISTS (
+		SELECT *
+		FROM Temp_MTG_Player_Save_Player T_PLAYER
+		WHERE T_PLAYER.is_duplicate
+		LIMIT 1
+	) THEN
+		INSERT INTO Temp_MTG_Player_Save_Error (
+			  error_type_id
+			, message
+		)
+		SELECT
+			  v_bad_data_error_type_id -- error_type_id
+			, CONCAT(
+				  'Duplicate on '
+				, T_PLAYER.error_name
+			) -- message
+		FROM Temp_MTG_Player_Save_Player T_PLAYER
+		WHERE T_PLAYER.is_duplicate
+		;
+	END IF;
+
+	-- Nothing to save
+	IF NOT EXISTS (SELECT * FROM Temp_MTG_Player_Save_Player LIMIT 1) THEN
+		INSERT INTO Temp_MTG_Player_Save_Error (
+			  error_type_id
+			, message
+		)
+		VALUES (
+			  v_warning_error_type_id
+			, 'Nothing to save.'
+		);
+	END IF;
+
+	-- Outputs
+	-- Change Set
+	INSERT INTO tcg.public.TCG_Change_Set (
+		  comment
+		, updated_last_by_user_id
+	)
+	VALUES (
+		  a_comment
+		, a_user_id
+	)
+	RETURNING change_set_id INTO v_change_set_id
+	;
+	
+	IF NOT EXISTS (SELECT * FROM Temp_MTG_Player_Save_Error T_ERROR WHERE T_ERROR.error_type_id <> v_warning_error_type_id LIMIT 1) THEN
+		
+		-- Player
+		INSERT INTO tcg.public.TCG_MTG_Game_Player (
+              game_id
+            , user_id
+            , deck_id
+            , name
+            , notes
+            , display_order
+            , active
+            , created_on
+            , created_by_user_id
+            , updated_last_on
+            , updated_last_by_user_id
+            , change_set_id
+		)
+		SELECT
+			  T_PLAYER.game_id
+            , T_PLAYER.user_id
+            , T_PLAYER.deck_id
+            , T_PLAYER.name
+            , T_PLAYER.notes
+            , T_PLAYER.display_order
+		    , T_PLAYER.active
+			, v_time_start -- created_on
+			, a_user_id -- created_by_user_id
+			, v_time_start -- updated_last_on
+			, a_user_id -- updated_last_by_user_id
+		    , v_change_set_id -- change_set_id
+		FROM Temp_MTG_Player_Save_Player T_PLAYER
+        LEFT JOIN Temp_MTG_Player_Save_Game T_GAME ON T_PLAYER.game_id = T_GAME.game_id
+		WHERE
+				T_PLAYER.is_new = TRUE
+			AND T_PLAYER.active = TRUE
+        ORDER BY
+              T_GAME.created_on
+            , T_PLAYER.display_order
+		;
+	
+		UPDATE tcg.public.TCG_MTG_Game_Player PLAYER
+		SET
+              game_id = T_PLAYER.game_id
+            , user_id = T_PLAYER.user_id
+            , deck_id = T_PLAYER.deck_id
+            , name = T_PLAYER.name
+            , notes = T_PLAYER.notes
+            , display_order = T_PLAYER.display_order
+		    , active = T_PLAYER.active
+			, updated_last_on = v_time_start
+			, updated_last_by_user_id = a_user_id
+		    , change_set_id = v_change_set_id
+		FROM Temp_MTG_Player_Save_Player T_PLAYER
+		WHERE
+				PLAYER.player_id = T_PLAYER.player_id
+			AND NOT T_PLAYER.is_new
+		;
+	ELSE
+		-- Error
+		INSERT INTO tcg.public.Error (
+			  guid
+			, error_type_id
+			, message
+			, display_order
+			, created_on
+			, created_by_user_id
+			, updated_last_on
+			, updated_last_by_user_id
+			, change_set_id
+		)
+		SELECT
+			  a_guid
+			, T_ERROR.error_type_id
+			, T_ERROR.message
+			, T_ERROR.temp_id
+			, v_time_start
+			, a_user_id
+			, v_time_start
+			, a_user_id
+			, v_change_set_id
+		FROM Temp_MTG_Player_Save_Error T_ERROR
+		LEFT JOIN tcg.public.Error_Type ERROR_TYPE ON T_ERROR.error_type_id = ERROR_TYPE.error_type_id
+		ORDER BY T_ERROR.temp_id
+		;
+	END IF;
+
+    COMMIT;
+	
+	o_success := NOT EXISTS (
+		SELECT *
+		FROM Temp_MTG_Player_Save_Error T_ERROR
+		WHERE T_ERROR.error_type_id <> v_warning_error_type_id
+		LIMIT 1
+	);
+	
+	DELETE FROM tcg.public.TCG_MTG_Game_Player_Temp PLAYER_T WHERE PLAYER_T.guid = a_guid;
+
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_Game;
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_User;
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_Deck;
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_Player;
+	DROP TABLE IF EXISTS Temp_MTG_Player_Save_Error;
+END;
+$$;
+
+
+-- Call it with:
+DO $$
+DECLARE
+	v_comment TEXT := 'MTG Game Player Save.';
+	v_guid UUID;
+    v_user_id INT := 3;
+    v_success BOOLEAN;
+BEGIN
+	v_guid := gen_random_uuid();
+
+	INSERT INTO tcg.public.TCG_MTG_Game_Player_Temp (
+		  guid
+        , player_id
+        , game_id
+        , user_id
+        , deck_id
+        , name
+        , notes
+        , display_order
+        , active
+	)
+	VALUES
+          (
+              v_guid
+            , NULL -- player_id
+            , 4 -- game_id
+            , 3 -- user_id
+            , 1 -- deck_id
+            , 'Teddy' -- name
+            , NULL -- notes
+            , 1 -- display_order
+            , TRUE -- active
+        )
+        , (
+              v_guid
+            , NULL -- player_id
+            , 4 -- game_id
+            , 3 -- user_id
+            , 2 -- deck_id
+            , 'Teddy' -- name
+            , NULL -- notes
+            , 2 -- display_order
+            , TRUE -- active
+        )
+        , (
+              v_guid
+            , NULL -- player_id
+            , 4 -- game_id
+            , 4 -- user_id
+            , 3 -- deck_id
+            , 'Teddy' -- name
+            , NULL -- notes
+            , 3 -- display_order
+            , TRUE -- active
+        )
+        , (
+              v_guid
+            , NULL -- player_id
+            , 4 -- game_id
+            , 5 -- user_id
+            , 4 -- deck_id
+            , 'Teddy' -- name
+            , NULL -- notes
+            , 4 -- display_order
+            , TRUE -- active
+        )
+        , (
+              v_guid
+            , NULL -- player_id
+            , 4 -- game_id
+            , 3 -- user_id
+            , 5 -- deck_id
+            , 'Teddy' -- name
+            , NULL -- notes
+            , 5 -- display_order
+            , TRUE -- active
+        )
+    ;
+
+    CALL tcg.public.USP_TCG_MTG_Game_Player_Save (
+		  v_comment -- a_comment
+		, v_guid -- a_guid
+		, v_user_id -- a_user_id
+		, v_success -- o_success
+	);
+    RAISE NOTICE 'Success: %', CASE WHEN v_success THEN 'TRUE' ELSE 'FALSE' END;
+END;
+$$;
+
+SELECT *
+-- DELETE
+FROM tcg.public.Error ERROR
+LEFT JOIN tcg.public.Error_Type ERROR_TYPE ON ERROR.error_type_id = ERROR_TYPE.error_type_id
+;
+SELECT *
+FROM tcg.public.Error_Type ERROR_TYPE
+;
+SELECT *
+FROM tcg.public.TCG_Change_Set CHANGE_SET
+ORDER BY CHANGE_SET.change_set_id  DESC
+;
+/*
+SELECT *
+FROM tcg.public.TCG_MTG_Game
+;
+*/
+SELECT *
+-- DELETE
+FROM tcg.public.TCG_MTG_Game_Player_Temp
+;
+SELECT *
+-- DELETE
+FROM tcg.public.TCG_MTG_Game_Player PLAYER
+LEFT JOIN tcg.public.TCG_MTG_Game GAME ON PLAYER.game_id = GAME.game_id
+;
+
+
+

static/PostgreSQL/71216_fn_TCG_MTG_Game_Round_Get_Many.sql

@@ -0,0 +1,101 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_TCG_MTG_Game_Round_Get_Many (
+      a_get_all_game BOOLEAN
+    , a_get_inactive_game BOOLEAN
+	, a_game_ids TEXT
+    , a_require_all_id_filters_met BOOLEAN
+    , a_require_any_id_filters_met BOOLEAN
+)
+RETURNS TABLE (
+      round_id INT
+	, game_id INT
+    , notes TEXT
+    , display_order INT
+    , active BOOLEAN
+    , created_on TIMESTAMP
+    , created_by_user_id INT
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+    , change_set_id INT
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    v_get_all_game BOOLEAN;
+    v_get_inactive_game BOOLEAN;
+	v_game_ids TEXT;
+    v_require_all_id_filters_met BOOLEAN;
+    v_require_any_id_filters_met BOOLEAN;
+BEGIN
+	v_get_all_game := COALESCE(a_get_all_game, FALSE);
+    v_get_inactive_game := COALESCE(a_get_inactive_game, FALSE);
+	v_game_ids := TRIM(COALESCE(a_game_ids, ''));
+    v_require_all_id_filters_met := COALESCE(a_require_all_id_filters_met, FALSE);
+    v_require_any_id_filters_met := COALESCE(a_require_any_id_filters_met, FALSE);
+	
+	-- Outputs
+
+    RETURN QUERY SELECT
+          ROUND.round_id
+        , ROUND.game_id
+        , ROUND.notes
+        , ROUND.display_order
+        , ROUND.active
+        , ROUND.created_on
+        , ROUND.created_by_user_id
+        , ROUND.updated_last_on
+        , ROUND.updated_last_by_user_id
+        , ROUND.change_set_id
+    FROM tcg.public.TCG_MTG_Game_Round ROUND
+    INNER JOIN tcg.public.TCG_MTG_Game GAME ON ROUND.game_id = GAME.game_id
+    WHERE
+            (
+                (
+                    NOT v_require_all_id_filters_met
+                AND NOT v_require_any_id_filters_met
+            )
+            OR  (
+                    v_require_all_id_filters_met
+                AND (
+                        v_get_all_game
+                    OR  ROUND.game_id = ANY(string_to_array(v_game_ids, ',')::INT[])
+                )
+            )
+            OR  (
+                    NOT v_require_all_id_filters_met
+                AND v_require_any_id_filters_met
+                AND (
+                        v_get_all_game
+                    OR  ROUND.game_id = ANY(string_to_array(v_game_ids, ',')::INT[])
+                )
+            )
+        )
+        AND (
+                v_get_inactive_game
+            OR  ROUND.active
+        )
+	ORDER BY
+          GAME.created_on DESC
+        , ROUND.display_order
+    ;
+END;
+$$;
+
+
+SELECT *
+FROM tcg.public.FN_TCG_MTG_Game_Round_Get_Many (
+      a_get_all_game := FALSE
+    , a_get_inactive_game := FALSE
+    , a_game_ids := '11'
+    , a_require_all_id_filters_met := TRUE 
+    , a_require_any_id_filters_met := FALSE 
+)
+;
+
+
+SELECT *
+FROM tcg.public.TCG_MTG_Game
+;
+SELECT *
+FROM tcg.public.TCG_MTG_Game_Round
+;

static/PostgreSQL/71220_fn_TCG_MTG_Game_Round_Player_Damage_Get_Many.sql

@@ -0,0 +1,110 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_TCG_MTG_Game_Round_Player_Damage_Get_Many (
+      a_get_all_game BOOLEAN
+    , a_get_inactive_game BOOLEAN
+	, a_game_ids TEXT
+    , a_require_all_id_filters_met BOOLEAN
+    , a_require_any_id_filters_met BOOLEAN
+)
+RETURNS TABLE (
+      damage_id INT
+    , round_id INT
+    , player_id INT
+    , received_from_commander_player_id INT
+    , health_change INT
+    , commander_deaths INT
+    , is_eliminated BOOLEAN
+    , active BOOLEAN
+    , created_on TIMESTAMP
+    , created_by_user_id INT
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+    , change_set_id INT
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+    v_get_all_game BOOLEAN;
+    v_get_inactive_game BOOLEAN;
+	v_game_ids TEXT;
+    v_require_all_id_filters_met BOOLEAN;
+    v_require_any_id_filters_met BOOLEAN;
+BEGIN
+	v_get_all_game := COALESCE(a_get_all_game, FALSE);
+    v_get_inactive_game := COALESCE(a_get_inactive_game, FALSE);
+	v_game_ids := TRIM(COALESCE(a_game_ids, ''));
+    v_require_all_id_filters_met := COALESCE(a_require_all_id_filters_met, FALSE);
+    v_require_any_id_filters_met := COALESCE(a_require_any_id_filters_met, FALSE);
+	
+	-- Outputs
+    RETURN QUERY SELECT
+          PLAYER_DAMAGE.damage_id
+        , PLAYER_DAMAGE.round_id
+        , PLAYER_DAMAGE.player_id
+        , PLAYER_DAMAGE.received_from_commander_player_id
+        , PLAYER_DAMAGE.health_change
+        , PLAYER_DAMAGE.commander_deaths
+		, PLAYER_DAMAGE.is_eliminated
+        , PLAYER_DAMAGE.active
+        , PLAYER_DAMAGE.created_on
+        , PLAYER_DAMAGE.created_by_user_id
+        , PLAYER_DAMAGE.updated_last_on
+        , PLAYER_DAMAGE.updated_last_by_user_id
+        , PLAYER_DAMAGE.change_set_id
+    FROM tcg.public.TCG_MTG_Game_Round_Player_Damage PLAYER_DAMAGE
+    INNER JOIN tcg.public.TCG_MTG_Game_Round GAME_ROUND ON PLAYER_DAMAGE.round_id = GAME_ROUND.round_id
+    INNER JOIN tcg.public.TCG_MTG_Game GAME ON GAME_ROUND.game_id = GAME.game_id
+	INNER JOIN tcg.public.TCG_MTG_Game_Player PLAYER ON PLAYER_DAMAGE.player_id = PLAYER.player_id
+    WHERE
+            (
+                (
+                    NOT v_require_all_id_filters_met
+                AND NOT v_require_any_id_filters_met
+            )
+            OR  (
+                    v_require_all_id_filters_met
+                AND (
+                        v_get_all_game
+                    OR  GAME.game_id = ANY(string_to_array(v_game_ids, ',')::INT[])
+                )
+            )
+            OR  (
+                    NOT v_require_all_id_filters_met
+                AND v_require_any_id_filters_met
+                AND (
+                        v_get_all_game
+                    OR  GAME.game_id = ANY(string_to_array(v_game_ids, ',')::INT[])
+                )
+            )
+        )
+        AND (
+                v_get_inactive_game
+            OR  PLAYER_DAMAGE.active
+        )
+	ORDER BY
+          GAME.created_on DESC
+        , GAME_ROUND.display_order
+        , PLAYER.display_order
+		, PLAYER_DAMAGE.damage_id
+    ;
+END;
+$$;
+
+
+SELECT *
+FROM tcg.public.FN_TCG_MTG_Game_Round_Player_Damage_Get_Many (
+      a_get_all_game := FALSE
+    , a_get_inactive_game := FALSE
+    , a_game_ids := '11'
+    , a_require_all_id_filters_met := TRUE 
+    , a_require_any_id_filters_met := FALSE 
+)
+;
+
+
+SELECT *
+FROM tcg.public.TCG_MTG_Game
+;
+SELECT *
+FROM tcg.public.TCG_MTG_Game_Round_Player_Damage
+;

static/PostgreSQL/71221_usp_TCG_MTG_Game_Round_Damage_Save.sql

@@ -0,0 +1,978 @@
+
+CREATE OR REPLACE PROCEDURE tcg.public.USP_TCG_MTG_Game_Round_Damage_Save (
+      a_comment TEXT
+    , a_guid UUID
+    , a_user_id INT
+	, OUT o_success BOOLEAN
+)
+LANGUAGE plpgsql
+AS $$
+DECLARE
+	v_bad_data_error_type_id INT;
+	v_change_set_id INT;
+	-- v_error_message TEXT;
+    v_no_permission_error_type_id INT;
+	v_time_start TIMESTAMP;
+	v_warning_error_type_id INT;
+BEGIN
+	v_bad_data_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'BAD_DATA' LIMIT 1);
+	v_no_permission_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'NO_PERMISSION' LIMIT 1);
+	v_warning_error_type_id := (SELECT ERROR_TYPE.error_type_id FROM tcg.public.Error_Type ERROR_TYPE WHERE ERROR_TYPE.code = 'WARNING' LIMIT 1);
+	v_time_start := CURRENT_TIMESTAMP;
+	
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Game;
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Player;
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Round;
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Round_Player_Damage;
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Error;
+    
+    CREATE TABLE Temp_MTG_Round_Damage_Save_Game (
+          game_id INT NOT NULL
+        , notes TEXT
+        , is_commander BOOLEAN
+        , is_draft BOOLEAN
+        , is_sealed BOOLEAN
+        , location_name TEXT
+        , start_on TIMESTAMP
+        , end_on TIMESTAMP
+        , active BOOLEAN
+        , created_on TIMESTAMP
+        , created_by_user_id INT
+        , updated_last_on TIMESTAMP
+        , updated_last_by_user_id INT
+        , change_set_id INT
+    );
+
+    CREATE TABLE Temp_MTG_Round_Damage_Save_Player (
+          player_id INT NOT NULL
+        , game_id INT
+        , user_id INT
+        , deck_id INT
+        , name TEXT
+        , notes TEXT
+        , display_order INT
+        , active BOOLEAN
+        , created_on TIMESTAMP
+        , created_by_user_id INT
+        , updated_last_on TIMESTAMP
+        , updated_last_by_user_id INT
+		, change_set_id INT
+    );
+
+    CREATE TABLE Temp_MTG_Round_Damage_Save_Round (
+          temp_id INT NOT NULL
+        , round_id INT
+        , game_id INT
+        , notes TEXT
+        , display_order INT
+        , active BOOLEAN
+        , created_on TIMESTAMP
+        , created_by_user_id INT
+        , updated_last_on TIMESTAMP
+        , updated_last_by_user_id INT
+		, change_set_id INT
+
+        , is_new BOOLEAN
+        , error_name TEXT
+        , is_duplicate BOOLEAN
+    );
+
+    CREATE TABLE Temp_MTG_Round_Damage_Save_Round_Player_Damage (
+          temp_id INT NOT NULL
+        , damage_id INT
+        , temp_round_id INT
+        , round_id INT
+        , player_id INT
+        , received_from_commander_player_id INT
+        , health_change INT
+        , commander_deaths INT
+		, is_eliminated BOOLEAN
+        , active BOOLEAN
+        , created_on TIMESTAMP
+        , created_by_user_id INT
+        , updated_last_on TIMESTAMP
+        , updated_last_by_user_id INT
+		, change_set_id INT
+
+        , is_new BOOLEAN
+        , error_name TEXT
+        , is_duplicate BOOLEAN
+    );
+
+	CREATE TEMP TABLE Temp_MTG_Round_Damage_Save_Error (
+		  temp_id INT GENERATED ALWAYS AS IDENTITY
+		, error_type_id INT
+		, message TEXT
+	);
+
+    IF NOT EXISTS (SELECT * FROM tcg.public.TCG_User TCG_USER WHERE TCG_USER.user_id = a_user_id LIMIT 1) THEN
+        INSERT INTO Temp_MTG_Round_Damage_Save_Error (
+            error_type_id
+            , message
+        )
+        VALUES (
+            v_no_permission_error_type_id -- error_type_id
+            , CONCAT(
+                'User does not exist: '
+                , CAST(a_user_id AS VARCHAR)
+                , '.'
+            ) -- message
+        );
+    END IF;
+	
+	INSERT INTO Temp_MTG_Round_Damage_Save_Round (
+		  temp_id
+        , round_id
+        , game_id
+        , notes
+        , display_order
+        , active
+        , created_on
+        , created_by_user_id
+        , updated_last_on
+        , updated_last_by_user_id
+
+		, is_new
+		, error_name
+	)
+	SELECT
+		  ROUND_T.temp_id
+        , ROUND_T.round_id
+        , ROUND_T.game_id
+        , ROUND_T.notes
+        , ROUND_T.display_order
+        , COALESCE(ROUND_T.active, TRUE)
+        , COALESCE(ROUND_T.created_on, v_time_start) -- created_on
+        , COALESCE(ROUND_T.created_by_user_id, a_user_id) -- created_by_user_id
+        , COALESCE(ROUND_T.updated_last_on, v_time_start) -- updated_last_on
+        , COALESCE(ROUND_T.updated_last_by_user_id, a_user_id) -- updated_last_by_user_id
+
+		, CASE WHEN ROUND.round_id IS NULL THEN TRUE ELSE FALSE END AS is_new
+		, CONCAT(
+			  'Round { id: '
+			, CAST(ROUND_T.round_id AS VARCHAR)
+			, ', temp id: '
+			, CAST(ROUND_T.temp_id AS VARCHAR)
+			, ', display order: '
+			, CAST(ROUND_T.display_order AS VARCHAR)
+			, ', game id: '
+			, CAST(ROUND_T.game_id AS VARCHAR)
+			, ' }'
+		) -- error_name
+	FROM tcg.public.TCG_MTG_Game_Round_Temp ROUND_T
+	LEFT JOIN tcg.public.TCG_MTG_Game_Round ROUND
+		ON  ROUND_T.round_id = ROUND.round_id
+		OR  (
+				COALESCE(ROUND_T.round_id, 0) < 1
+			AND ROUND_T.game_id = ROUND.game_id
+			AND ROUND_T.display_order = ROUND.display_order
+		)
+	WHERE ROUND_T.guid = a_guid
+	;
+	
+	INSERT INTO Temp_MTG_Round_Damage_Save_Round_Player_Damage (
+		  temp_id
+        , damage_id
+        , temp_round_id
+        , round_id
+        , player_id
+        , received_from_commander_player_id
+        , health_change
+        , commander_deaths
+		, is_eliminated
+        , active
+        , created_on
+        , created_by_user_id
+        , updated_last_on
+        , updated_last_by_user_id
+
+		, is_new
+		, error_name
+	)
+	SELECT
+		  PLAYER_DAMAGE_T.temp_id
+        , CASE WHEN COALESCE(PLAYER_DAMAGE_T.damage_id, 0) < 1 
+			THEN COALESCE(PLAYER_DAMAGE.damage_id, PLAYER_DAMAGE_T.damage_id, 0)
+			ELSE PLAYER_DAMAGE_T.damage_id
+		END -- damage_id
+        , T_ROUND.temp_id AS temp_round_id
+        , PLAYER_DAMAGE_T.round_id
+        , PLAYER_DAMAGE_T.player_id
+        , PLAYER_DAMAGE_T.received_from_commander_player_id
+        , COALESCE(PLAYER_DAMAGE_T.health_change, 0) -- health_change
+        , COALESCE(PLAYER_DAMAGE_T.commander_deaths, 0) -- commander_deaths
+		, COALESCE(PLAYER_DAMAGE_T.is_eliminated, FALSE) -- is_eliminated
+        , COALESCE(PLAYER_DAMAGE_T.active, TRUE) -- active
+        , COALESCE(PLAYER_DAMAGE_T.created_on, v_time_start) -- created_on
+        , COALESCE(PLAYER_DAMAGE_T.created_by_user_id, a_user_id) -- created_by_user_id
+        , COALESCE(PLAYER_DAMAGE_T.updated_last_on, v_time_start) -- updated_last_on
+        , COALESCE(PLAYER_DAMAGE_T.updated_last_by_user_id, a_user_id) -- updated_last_by_user_id
+
+		, CASE WHEN PLAYER_DAMAGE.damage_id IS NULL THEN TRUE ELSE FALSE END AS is_new
+		, CONCAT(
+			  'Round Player Damage { id: '
+			, CAST(PLAYER_DAMAGE_T.damage_id AS VARCHAR)
+			, ', temp id: '
+			, CAST(PLAYER_DAMAGE_T.temp_id AS VARCHAR)
+			, ', round id: '
+			, CAST(PLAYER_DAMAGE_T.round_id AS VARCHAR)
+			, ', player id: '
+			, CAST(PLAYER_DAMAGE_T.player_id AS VARCHAR)
+			, ', received from commander player id: '
+			, CAST(PLAYER_DAMAGE_T.received_from_commander_player_id AS VARCHAR)
+			, ', health change: '
+			, CAST(PLAYER_DAMAGE_T.health_change AS VARCHAR)
+			, ' }'
+		) -- error_name
+	FROM tcg.public.TCG_MTG_Game_Round_Player_Damage_Temp PLAYER_DAMAGE_T
+	LEFT JOIN tcg.public.TCG_MTG_Game_Round_Player_Damage PLAYER_DAMAGE
+		ON 	PLAYER_DAMAGE_T.damage_id = PLAYER_DAMAGE.damage_id
+		OR  (
+				COALESCE(PLAYER_DAMAGE_T.damage_id, 0) < 1
+			AND PLAYER_DAMAGE_T.round_id = PLAYER_DAMAGE.round_id
+			AND PLAYER_DAMAGE_T.player_id = PLAYER_DAMAGE.player_id
+			AND (
+					PLAYER_DAMAGE_T.received_from_commander_player_id = PLAYER_DAMAGE.received_from_commander_player_id
+				OR  (
+						PLAYER_DAMAGE_T.received_from_commander_player_id IS NULL
+					AND PLAYER_DAMAGE.received_from_commander_player_id IS NULL
+				)
+			)
+		)
+    LEFT JOIN Temp_MTG_Round_Damage_Save_Round T_ROUND ON PLAYER_DAMAGE_T.round_id = T_ROUND.round_id
+	WHERE PLAYER_DAMAGE_T.guid = a_guid
+	;
+
+	UPDATE Temp_MTG_Round_Damage_Save_Round
+	SET round_id = COALESCE(ROUND.round_id, ROUND_T.round_id, 0)
+	FROM tcg.public.TCG_MTG_Game_Round_Temp ROUND_T
+	LEFT JOIN tcg.public.TCG_MTG_Game_Round ROUND
+		ON  ROUND_T.round_id = ROUND.round_id
+		OR  (
+				ROUND_T.game_id = ROUND.game_id
+			AND ROUND_T.display_order = ROUND.display_order
+		)
+	WHERE COALESCE(ROUND_T.round_id, 0) < 1
+	;
+
+	UPDATE Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+	SET damage_id = COALESCE(PLAYER_DAMAGE.damage_id, T_PLAYER_DAMAGE.damage_id, 0)
+	/* FROM tcg.public.TCG_MTG_Game_Round_Player_Damage PLAYER_DAMAGE
+    LEFT JOIN  */
+	FROM tcg.public.TCG_MTG_Game_Round_Player_Damage PLAYER_DAMAGE
+	INNER JOIN Temp_MTG_Round_Damage_Save_Round T_ROUND ON PLAYER_DAMAGE.round_id = T_ROUND.round_id
+	WHERE
+			( 
+			 	T_PLAYER_DAMAGE.damage_id = PLAYER_DAMAGE.damage_id
+			OR  (
+					T_ROUND.round_id = PLAYER_DAMAGE.round_id
+				AND T_PLAYER_DAMAGE.player_id = PLAYER_DAMAGE.player_id
+				AND (
+						T_PLAYER_DAMAGE.received_from_commander_player_id = PLAYER_DAMAGE.received_from_commander_player_id
+					OR  (
+							T_PLAYER_DAMAGE.received_from_commander_player_id IS NULL
+						AND PLAYER_DAMAGE.received_from_commander_player_id IS NULL
+					)
+				)
+			)
+		)
+		AND T_PLAYER_DAMAGE.temp_round_id = T_ROUND.temp_id
+		AND COALESCE(T_PLAYER_DAMAGE.damage_id, 0) < 1
+	;
+	
+    INSERT INTO Temp_MTG_Round_Damage_Save_Game (
+          game_id
+        , notes
+        , is_commander
+        , is_draft
+        , is_sealed
+        , location_name
+        , start_on
+        , end_on
+        , active
+        , created_on
+        , created_by_user_id
+        , updated_last_on
+        , updated_last_by_user_id
+        , change_set_id
+    )
+	SELECT DISTINCT
+		  GAME.game_id
+        , GAME.notes
+        , GAME.is_commander
+        , GAME.is_draft
+        , GAME.is_sealed
+        , GAME.location_name
+        , GAME.start_on
+        , GAME.end_on
+        , GAME.active
+        , GAME.created_on
+        , GAME.created_by_user_id
+        , GAME.updated_last_on
+        , GAME.updated_last_by_user_id
+        , GAME.change_set_id
+	FROM tcg.public.TCG_MTG_Game GAME
+	INNER JOIN Temp_MTG_Round_Damage_Save_Round T_ROUND ON GAME.game_id = T_ROUND.game_id
+	;
+	
+	INSERT INTO Temp_MTG_Round_Damage_Save_Player (
+		  player_id
+        , game_id
+        , user_id
+        , deck_id
+        , name
+        , notes
+        , display_order
+        , active
+        , created_on
+        , created_by_user_id
+        , updated_last_on
+        , updated_last_by_user_id
+		, change_set_id
+	)
+	SELECT DISTINCT
+		  PLAYER.player_id
+        , PLAYER.game_id
+        , PLAYER.user_id
+        , PLAYER.deck_id
+        , PLAYER.name
+        , PLAYER.notes
+        , PLAYER.display_order
+        , PLAYER.active
+        , PLAYER.created_on
+        , PLAYER.created_by_user_id
+        , PLAYER.updated_last_on
+        , PLAYER.updated_last_by_user_id
+        , PLAYER.change_set_id
+	FROM tcg.public.TCG_MTG_Game_Player PLAYER
+	INNER JOIN Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        ON  PLAYER.player_id = T_PLAYER_DAMAGE.player_id
+        OR  PLAYER.player_id = T_PLAYER_DAMAGE.received_from_commander_player_id
+	;
+    
+    -- Validate Round
+	-- Missing fields
+	WITH Round_Missing_Field AS (
+        SELECT
+              T_ROUND.temp_id
+            , 'game_id' AS field
+        FROM Temp_MTG_Round_Damage_Save_Round T_ROUND
+        WHERE T_ROUND.game_id IS NULL
+    )
+	INSERT INTO Temp_MTG_Round_Damage_Save_Error (
+		  error_type_id
+		, message
+	)
+	SELECT
+		  v_bad_data_error_type_id -- error_type_id
+		, CONCAT(
+			'Missing mandatory field: '
+			, ROUND_MISSING_FIELD.field
+			, ' on '
+			, T_ROUND.error_name
+			, '.'
+		) -- message
+	FROM Temp_MTG_Round_Damage_Save_Round T_ROUND
+	INNER JOIN Round_Missing_Field ROUND_MISSING_FIELD ON T_ROUND.temp_id = ROUND_MISSING_FIELD.temp_id
+	;
+
+	-- Failed join fields
+	WITH Round_Failed_Join_Field AS (
+        SELECT
+              T_ROUND.temp_id
+            , 'game_id' AS field
+        FROM Temp_MTG_Round_Damage_Save_Round T_ROUND
+        LEFT JOIN Temp_MTG_Round_Damage_Save_Game T_GAME ON T_ROUND.game_id = T_GAME.game_id
+        WHERE T_GAME.game_id IS NULL
+    )
+	INSERT INTO Temp_MTG_Round_Damage_Save_Error (
+		  error_type_id
+		, message
+	)
+	SELECT
+		  v_bad_data_error_type_id -- error_type_id
+		, CONCAT(
+			'Failed relationship: '
+			, ROUND_FAILED_JOIN_FIELD.field
+			, ' on '
+			, T_ROUND.error_name
+			, '.'
+		) -- message
+	FROM Temp_MTG_Round_Damage_Save_Round T_ROUND
+	INNER JOIN Round_Failed_Join_Field ROUND_FAILED_JOIN_FIELD ON T_ROUND.temp_id = ROUND_FAILED_JOIN_FIELD.temp_id
+	;
+
+	-- Duplicate
+	WITH 
+		  All_Round AS (
+			SELECT
+				  T_ROUND.temp_id
+                , T_ROUND.game_id
+                , T_ROUND.display_order
+                , TRUE AS is_save_record
+			FROM Temp_MTG_Round_Damage_Save_Round T_ROUND
+            UNION
+			SELECT
+				  NULL AS temp_id
+                , ROUND.game_id
+                , ROUND.display_order
+                , FALSE AS is_save_record
+			FROM tcg.public.TCG_MTG_Game_Round ROUND
+            LEFT JOIN Temp_MTG_Round_Damage_Save_Round T_ROUND ON ROUND.round_id = T_ROUND.round_id
+            WHERE
+                    T_ROUND.round_id IS NULL
+                AND ROUND.active
+		)
+		, Unique_Game_Round AS (
+			SELECT
+				  ALL_ROUND.game_id
+                , ALL_ROUND.display_order
+                , COUNT(*) AS count
+			FROM All_Round ALL_ROUND
+            GROUP BY
+                  ALL_ROUND.game_id
+                , ALL_ROUND.display_order
+		)
+	UPDATE Temp_MTG_Round_Damage_Save_Round T_ROUND
+	SET is_duplicate = CASE WHEN COALESCE(UNIQUE_GAME_ROUND.count, 0) > 1 THEN TRUE ELSE FALSE END
+	FROM Unique_Game_Round UNIQUE_GAME_ROUND
+	WHERE
+            T_ROUND.game_id = UNIQUE_GAME_ROUND.game_id
+        AND T_ROUND.display_order = UNIQUE_GAME_ROUND.display_order
+	;
+	
+	IF EXISTS (
+		SELECT *
+		FROM Temp_MTG_Round_Damage_Save_Round T_ROUND
+		WHERE T_ROUND.is_duplicate
+		LIMIT 1
+	) THEN
+		INSERT INTO Temp_MTG_Round_Damage_Save_Error (
+			  error_type_id
+			, message
+		)
+		SELECT
+			  v_bad_data_error_type_id -- error_type_id
+			, CONCAT(
+				  'Duplicate on '
+				, T_ROUND.error_name
+			) -- message
+		FROM Temp_MTG_Round_Damage_Save_Round T_ROUND
+		WHERE T_ROUND.is_duplicate
+		;
+	END IF;
+    
+    -- Validate Damage
+	-- Missing fields
+	WITH Player_Damage_Missing_Field AS (
+        SELECT
+              T_PLAYER_DAMAGE.temp_id
+            , 'round_id' AS field
+        FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        WHERE T_PLAYER_DAMAGE.round_id IS NULL
+        UNION
+        SELECT
+              T_PLAYER_DAMAGE.temp_id
+            , 'player_id' AS field
+        FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        WHERE T_PLAYER_DAMAGE.player_id IS NULL
+        UNION
+        SELECT
+              T_PLAYER_DAMAGE.temp_id
+            , 'health_change' AS field
+        FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        WHERE T_PLAYER_DAMAGE.health_change IS NULL
+        UNION
+        SELECT
+              T_PLAYER_DAMAGE.temp_id
+            , 'commander_deaths' AS field
+        FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        WHERE T_PLAYER_DAMAGE.commander_deaths IS NULL
+    )
+	INSERT INTO Temp_MTG_Round_Damage_Save_Error (
+		  error_type_id
+		, message
+	)
+	SELECT
+		  v_bad_data_error_type_id -- error_type_id
+		, CONCAT(
+			'Missing mandatory field: '
+			, PLAYER_DAMAGE_MISSING_FIELD.field
+			, ' on '
+			, T_PLAYER_DAMAGE.error_name
+			, '.'
+		) -- message
+	FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+	INNER JOIN Player_Damage_Missing_Field PLAYER_DAMAGE_MISSING_FIELD ON T_PLAYER_DAMAGE.temp_id = PLAYER_DAMAGE_MISSING_FIELD.temp_id
+	;
+
+	-- Failed join fields
+	WITH Player_Failed_Join_Field AS (
+        SELECT
+              T_PLAYER_DAMAGE.temp_id
+            , 'round_id' AS field
+        FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        LEFT JOIN Temp_MTG_Round_Damage_Save_Round T_ROUND ON T_PLAYER_DAMAGE.temp_round_id = T_ROUND.temp_id
+        WHERE T_ROUND.round_id IS NULL
+        UNION
+        SELECT
+              T_PLAYER_DAMAGE.temp_id
+            , 'player_id' AS field
+        FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        LEFT JOIN Temp_MTG_Round_Damage_Save_Player T_PLAYER ON T_PLAYER_DAMAGE.player_id = T_PLAYER.player_id
+        WHERE T_PLAYER.player_id IS NULL
+        UNION
+        SELECT
+              T_PLAYER_DAMAGE.temp_id
+            , 'received_from_commander_player_id' AS field
+        FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        LEFT JOIN Temp_MTG_Round_Damage_Save_Player T_PLAYER ON T_PLAYER_DAMAGE.received_from_commander_player_id = T_PLAYER.player_id
+        WHERE
+				T_PLAYER.player_id IS NULL
+			AND T_PLAYER_DAMAGE.received_from_commander_player_id IS NOT NULL
+    )
+	INSERT INTO Temp_MTG_Round_Damage_Save_Error (
+		  error_type_id
+		, message
+	)
+	SELECT
+		  v_bad_data_error_type_id -- error_type_id
+		, CONCAT(
+			'Failed relationship: '
+			, PLAYER_FAILED_JOIN_FIELD.field
+			, ' on '
+			, T_PLAYER_DAMAGE.error_name
+			, '.'
+		) -- message
+	FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+	INNER JOIN Player_Failed_Join_Field PLAYER_FAILED_JOIN_FIELD ON T_PLAYER_DAMAGE.temp_id = PLAYER_FAILED_JOIN_FIELD.temp_id
+	;
+
+	-- Duplicate Round Player Damage
+	WITH 
+		  All_Player_Damage AS (
+			SELECT
+				  T_PLAYER_DAMAGE.temp_id
+                , T_PLAYER_DAMAGE.round_id
+                , T_PLAYER_DAMAGE.player_id
+                , COALESCE(T_PLAYER_DAMAGE.received_from_commander_player_id, 0) AS received_from_commander_player_id
+                , TRUE AS is_save_record
+			FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+            UNION
+			SELECT
+				  NULL AS temp_id
+                , T_PLAYER_DAMAGE.round_id
+                , T_PLAYER_DAMAGE.player_id
+                , COALESCE(T_PLAYER_DAMAGE.received_from_commander_player_id, 0) AS received_from_commander_player_id
+                , FALSE AS is_save_record
+			FROM tcg.public.TCG_MTG_Game_Round_Player_Damage PLAYER_DAMAGE
+            LEFT JOIN Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE ON PLAYER_DAMAGE.damage_id = T_PLAYER_DAMAGE.damage_id
+            WHERE
+                    T_PLAYER_DAMAGE.damage_id IS NULL
+                AND PLAYER_DAMAGE.active
+		)
+		, Unique_Game_Player_Damage AS (
+			SELECT
+                  ALL_PLAYER_DAMAGE.round_id
+                , ALL_PLAYER_DAMAGE.player_id
+                , ALL_PLAYER_DAMAGE.received_from_commander_player_id
+                , COUNT(*) AS count
+			FROM All_Player_Damage ALL_PLAYER_DAMAGE
+            GROUP BY
+                  ALL_PLAYER_DAMAGE.round_id
+                , ALL_PLAYER_DAMAGE.player_id
+                , ALL_PLAYER_DAMAGE.received_from_commander_player_id
+		)
+	UPDATE Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+	SET is_duplicate = CASE WHEN COALESCE(UNIQUE_PLAYER_DAMAGE.count, 0) > 1 THEN TRUE ELSE FALSE END
+	FROM Unique_Game_Player_Damage UNIQUE_PLAYER_DAMAGE
+	WHERE
+        	T_PLAYER_DAMAGE.round_id = UNIQUE_PLAYER_DAMAGE.round_id
+        AND T_PLAYER_DAMAGE.player_id = UNIQUE_PLAYER_DAMAGE.player_id
+        AND T_PLAYER_DAMAGE.received_from_commander_player_id = UNIQUE_PLAYER_DAMAGE.received_from_commander_player_id
+	;
+	
+	IF EXISTS (
+		SELECT *
+		FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+		WHERE T_PLAYER_DAMAGE.is_duplicate
+		LIMIT 1
+	) THEN
+		INSERT INTO Temp_MTG_Round_Damage_Save_Error (
+			  error_type_id
+			, message
+		)
+		SELECT
+			  v_bad_data_error_type_id -- error_type_id
+			, CONCAT(
+				  'Duplicate on '
+				, T_PLAYER_DAMAGE.error_name
+			) -- message
+		FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+		WHERE T_PLAYER_DAMAGE.is_duplicate
+		;
+	END IF;
+
+	-- Nothing to save
+	IF  (
+            NOT EXISTS (SELECT * FROM Temp_MTG_Round_Damage_Save_Round LIMIT 1)
+        AND NOT EXISTS (SELECT * FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage LIMIT 1)
+    ) THEN
+		INSERT INTO Temp_MTG_Round_Damage_Save_Error (
+			  error_type_id
+			, message
+		)
+		VALUES (
+			  v_warning_error_type_id
+			, 'Nothing to save.'
+		);
+	END IF;
+
+	-- Outputs
+	/*
+	INSERT INTO Temp_MTG_Round_Damage_Save_Error (
+		  error_type_id
+		, message
+	)
+	VALUES
+		(
+			  v_bad_data_error_type_id -- error_type_id
+			, CONCAT(
+				'Temp round ids: '
+				, (SELECT STRING_AGG(CAST(T_ROUND.temp_id AS VARCHAR), ',') FROM Temp_MTG_Round_Damage_Save_Round T_ROUND)
+			) -- message
+		)
+		, (
+			  v_bad_data_error_type_id -- error_type_id
+			, CONCAT(
+				'Temp player damage ids: '
+				, (SELECT STRING_AGG(CAST(T_PLAYER_DAMAGE.temp_id AS VARCHAR), ',') FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE)
+			) -- message
+		)
+		, (
+			  v_bad_data_error_type_id -- error_type_id
+			, CONCAT(
+				'Temp player ids: '
+				, (SELECT STRING_AGG(CAST(T_PLAYER.player_id AS VARCHAR), ',') FROM Temp_MTG_Round_Damage_Save_Player T_PLAYER)
+			) -- message
+		)
+		, (
+			  v_bad_data_error_type_id -- error_type_id
+			, CONCAT(
+				'Temp game ids: '
+				, (SELECT STRING_AGG(CAST(T_GAME.game_id AS VARCHAR), ',') FROM Temp_MTG_Round_Damage_Save_Game T_GAME)
+			) -- message
+		)
+		, (
+			  v_bad_data_error_type_id -- error_type_id
+			, CONCAT(
+				'Query player damage ids: '
+				, (
+					SELECT STRING_AGG(CAST(T_PLAYER_DAMAGE.temp_id AS VARCHAR), ',')
+					FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+			        INNER JOIN Temp_MTG_Round_Damage_Save_Round T_ROUND ON T_PLAYER_DAMAGE.temp_round_id = T_ROUND.temp_id
+			        LEFT JOIN Temp_MTG_Round_Damage_Save_Game T_GAME ON T_ROUND.game_id = T_GAME.game_id
+			        LEFT JOIN Temp_MTG_Round_Damage_Save_Player T_PLAYER ON T_PLAYER_DAMAGE.player_id = T_PLAYER.player_id
+				)
+			) -- message
+		)
+	;
+	*/
+
+	-- Change Set
+	INSERT INTO tcg.public.TCG_Change_Set (
+		  comment
+		, updated_last_by_user_id
+	)
+	VALUES (
+		  a_comment
+		, a_user_id
+	)
+	RETURNING change_set_id INTO v_change_set_id
+	;
+	
+	IF NOT EXISTS (SELECT * FROM Temp_MTG_Round_Damage_Save_Error T_ERROR WHERE T_ERROR.error_type_id <> v_warning_error_type_id LIMIT 1) THEN
+		
+		-- Round
+		INSERT INTO tcg.public.TCG_MTG_Game_Round (
+              game_id
+            , notes
+            , display_order
+            , active
+            , created_on
+            , created_by_user_id
+            , updated_last_on
+            , updated_last_by_user_id
+            , change_set_id
+		)
+		SELECT
+			  T_ROUND.game_id
+            , T_ROUND.notes
+            , T_ROUND.display_order
+		    , T_ROUND.active
+			, v_time_start -- created_on
+			, a_user_id -- created_by_user_id
+			, v_time_start -- updated_last_on
+			, a_user_id -- updated_last_by_user_id
+		    , v_change_set_id -- change_set_id
+		FROM Temp_MTG_Round_Damage_Save_Round T_ROUND
+        LEFT JOIN Temp_MTG_Round_Damage_Save_Game T_GAME ON T_ROUND.game_id = T_GAME.game_id
+		WHERE
+				T_ROUND.is_new = TRUE
+			AND T_ROUND.active = TRUE
+		ORDER BY
+              T_GAME.created_on
+            , T_ROUND.display_order
+		;
+	
+		UPDATE tcg.public.TCG_MTG_Game_Round ROUND
+		SET
+              game_id = T_ROUND.game_id
+            , notes = T_ROUND.notes
+            , display_order = T_ROUND.display_order
+		    , active = T_ROUND.active
+			, updated_last_on = v_time_start
+			, updated_last_by_user_id = a_user_id
+		    , change_set_id = v_change_set_id
+		FROM Temp_MTG_Round_Damage_Save_Round T_ROUND
+		WHERE
+				ROUND.round_id = T_ROUND.round_id
+			AND NOT T_ROUND.is_new
+		;
+
+        UPDATE Temp_MTG_Round_Damage_Save_Round T_ROUND
+        SET round_id = ROUND.round_id
+        FROM tcg.public.TCG_MTG_Game_Round ROUND
+        WHERE
+                T_ROUND.game_id = ROUND.game_id
+            AND T_ROUND.display_order = ROUND.display_order
+            AND T_ROUND.is_new
+        ;
+
+		-- Round Player Damage
+		INSERT INTO tcg.public.TCG_MTG_Game_Round_Player_Damage (
+              round_id
+            , player_id
+            , received_from_commander_player_id
+            , health_change
+            , commander_deaths
+			, is_eliminated
+            , active
+            , created_on
+            , created_by_user_id
+            , updated_last_on
+            , updated_last_by_user_id
+            , change_set_id
+		)
+		SELECT
+			  T_ROUND.round_id
+            , T_PLAYER_DAMAGE.player_id
+            , T_PLAYER_DAMAGE.received_from_commander_player_id
+		    , T_PLAYER_DAMAGE.health_change
+		    , T_PLAYER_DAMAGE.commander_deaths
+			, T_PLAYER_DAMAGE.is_eliminated
+		    , T_PLAYER_DAMAGE.active
+			, v_time_start -- created_on
+			, a_user_id -- created_by_user_id
+			, v_time_start -- updated_last_on
+			, a_user_id -- updated_last_by_user_id
+		    , v_change_set_id -- change_set_id 
+		FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        INNER JOIN Temp_MTG_Round_Damage_Save_Round T_ROUND ON T_PLAYER_DAMAGE.temp_round_id = T_ROUND.temp_id
+        LEFT JOIN Temp_MTG_Round_Damage_Save_Game T_GAME ON T_ROUND.game_id = T_GAME.game_id
+        LEFT JOIN Temp_MTG_Round_Damage_Save_Player T_PLAYER ON T_PLAYER_DAMAGE.player_id = T_PLAYER.player_id
+		WHERE
+				T_PLAYER_DAMAGE.is_new = TRUE
+			AND T_PLAYER_DAMAGE.active = TRUE
+		ORDER BY
+              T_GAME.created_on
+			, T_ROUND.display_order
+			, T_PLAYER.display_order
+		;
+	
+		UPDATE tcg.public.TCG_MTG_Game_Round_Player_Damage PLAYER_DAMAGE
+		SET
+              round_id = T_ROUND.round_id
+            , player_id = T_PLAYER_DAMAGE.player_id
+            , received_from_commander_player_id = T_PLAYER_DAMAGE.received_from_commander_player_id
+		    , health_change = T_PLAYER_DAMAGE.health_change
+		    , commander_deaths = T_PLAYER_DAMAGE.commander_deaths
+			, is_eliminated = T_PLAYER_DAMAGE.is_eliminated
+		    , active = T_PLAYER_DAMAGE.active
+			, updated_last_on = v_time_start
+			, updated_last_by_user_id = a_user_id
+		    , change_set_id = v_change_set_id
+		FROM Temp_MTG_Round_Damage_Save_Round_Player_Damage T_PLAYER_DAMAGE
+        INNER JOIN Temp_MTG_Round_Damage_Save_Round T_ROUND ON T_PLAYER_DAMAGE.temp_round_id = T_ROUND.temp_id
+		WHERE
+				PLAYER_DAMAGE.damage_id = T_PLAYER_DAMAGE.damage_id
+			AND NOT T_PLAYER_DAMAGE.is_new
+		;
+	ELSE
+		-- Error
+		INSERT INTO tcg.public.Error (
+			  guid
+			, error_type_id
+			, message
+			, display_order
+			, created_on
+			, created_by_user_id
+			, updated_last_on
+			, updated_last_by_user_id
+			, change_set_id
+		)
+		SELECT
+			  a_guid
+			, T_ERROR.error_type_id
+			, T_ERROR.message
+			, T_ERROR.temp_id
+			, v_time_start
+			, a_user_id
+			, v_time_start
+			, a_user_id
+			, v_change_set_id
+		FROM Temp_MTG_Round_Damage_Save_Error T_ERROR
+		LEFT JOIN tcg.public.Error_Type ERROR_TYPE ON T_ERROR.error_type_id = ERROR_TYPE.error_type_id
+		ORDER BY T_ERROR.temp_id
+		;
+	END IF;
+
+    COMMIT;
+	
+	o_success := NOT EXISTS (
+		SELECT *
+		FROM Temp_MTG_Round_Damage_Save_Error T_ERROR
+		WHERE T_ERROR.error_type_id <> v_warning_error_type_id
+		LIMIT 1
+	);
+	
+	DELETE FROM tcg.public.TCG_MTG_Game_Round_Temp ROUND_T WHERE ROUND_T.guid = a_guid;
+	DELETE FROM tcg.public.TCG_MTG_Game_Round_Player_Damage_Temp ROUND_DAMAGE_T WHERE ROUND_DAMAGE_T.guid = a_guid;
+
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Game;
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Player;
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Round;
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Round_Player_Damage;
+	DROP TABLE IF EXISTS Temp_MTG_Round_Damage_Save_Error;
+END;
+$$;
+
+-- Call it with:
+DO $$
+DECLARE
+	v_comment TEXT := 'MTG Game Round Player Damage Save.';
+	v_guid UUID;
+    v_user_id INT := 3;
+    v_success BOOLEAN;
+BEGIN
+	v_guid := gen_random_uuid();
+
+	INSERT INTO tcg.public.TCG_MTG_Game_Round_Temp (
+		  guid
+	    , round_id
+        , game_id
+        , notes
+        , display_order
+        , active
+	)
+	VALUES (
+          v_guid -- guid
+        , -1 -- round_id
+        , 4 -- game_id
+        , 'Beaten' -- notes
+        , 5 -- display_order
+        , TRUE -- active
+    )
+    ;
+
+	INSERT INTO tcg.public.TCG_MTG_Game_Round_Player_Damage_Temp (
+		  guid
+        , damage_id
+        , round_id
+        , player_id
+        , received_from_commander_player_id
+        , health_change
+        , commander_deaths
+        , active
+	)
+	VALUES
+          (
+              v_guid -- guid
+            , NULL -- damage_id
+            , -1 -- round_id
+            , 3 -- player_id
+            , NULL -- received_from_commander_player_id
+            , -4 -- health_change
+            , 1 -- commander_deaths
+            , TRUE -- active
+        )
+		, (
+              v_guid -- guid
+            , NULL -- damage_id
+            , -1 -- round_id
+            , 3 -- player_id
+            , 2 -- received_from_commander_player_id
+            , -5 -- health_change
+            , NULL -- commander_deaths
+            , TRUE -- active
+        )
+		, (
+              v_guid -- guid
+            , NULL -- damage_id
+            , -1 -- round_id
+            , 3 -- player_id
+            , 5 -- received_from_commander_player_id
+            , -6 -- health_change
+            , NULL -- commander_deaths
+            , TRUE -- active
+        )
+    ;
+
+    CALL tcg.public.USP_TCG_MTG_Game_Round_Damage_Save (
+		  a_comment := v_comment -- a_comment
+		, a_guid := v_guid -- a_guid
+		, a_user_id := v_user_id -- a_user_id
+		, o_success := v_success -- o_success
+	);
+    RAISE NOTICE 'Success: %', CASE WHEN v_success THEN 'TRUE' ELSE 'FALSE' END;
+END;
+$$;
+
+SELECT *
+-- DELETE
+FROM tcg.public.Error ERROR
+LEFT JOIN tcg.public.Error_Type ERROR_TYPE ON ERROR.error_type_id = ERROR_TYPE.error_type_id
+;
+SELECT *
+FROM tcg.public.Error_Type ERROR_TYPE
+;
+SELECT *
+FROM tcg.public.TCG_Change_Set CHANGE_SET
+ORDER BY CHANGE_SET.change_set_id  DESC
+;
+/*
+SELECT *
+FROM tcg.public.TCG_MTG_Game
+;
+*/
+SELECT *
+-- DELETE
+FROM tcg.public.TCG_MTG_Game_Round_Temp
+;
+SELECT *
+-- DELETE
+FROM tcg.public.TCG_MTG_Game_Round_Player_Damage_Temp
+;
+SELECT *
+-- DELETE
+FROM tcg.public.TCG_MTG_Game_Round ROUND
+LEFT JOIN tcg.public.TCG_MTG_Game GAME ON ROUND.game_id = GAME.game_id
+;
+SELECT *
+-- DELETE
+FROM tcg.public.TCG_MTG_Game_Round_Player_Damage PLAYER_DAMAGE
+LEFT JOIN tcg.public.TCG_MTG_Game_Round ROUND ON PLAYER_DAMAGE.round_id = ROUND.round_id
+LEFT JOIN tcg.public.TCG_MTG_Game GAME ON ROUND.game_id = GAME.game_id
+;
+
+

static/PostgreSQL/90000_usp_populate.sql

@@ -0,0 +1,669 @@
+
+-- Change Set
+INSERT INTO tcg.public.TCG_Change_Set (
+    comment
+    , updated_last_by_user_id
+)
+VALUES (
+    'Initial population of lookup tables.'
+    , 3
+);
+
+-- User
+INSERT INTO tcg.public.TCG_User (
+    firstname
+    , surname
+    , email
+    , is_super_user
+    , change_set_id
+)
+VALUES (
+    'Teddy'
+    , 'Smith'
+    , 'edward.middletonsmith@gmail.com'
+    , TRUE
+    , 1
+);
+
+INSERT INTO tcg.public.TCG_Change_Set (
+    comment
+    , updated_last_by_user_id
+)
+VALUES (
+    'Alter created by user id in User table from initial upload.'
+    , 3
+);
+
+UPDATE tcg.public.TCG_User
+SET 
+	created_by_user_id = 3
+	, updated_last_by_user_id = 3
+	, change_set_id = 4
+;
+
+INSERT INTO tcg.public.TCG_Change_Set (
+    comment
+    , updated_last_by_user_id
+)
+VALUES (
+    'Add more users.'
+    , 3
+);
+
+SELECT * FROM tcg.public.TCG_Change_Set CS ORDER BY CS.change_set_id DESC LIMIT 1;
+
+INSERT INTO tcg.public.TCG_User (
+    firstname
+    , surname
+    , email
+    , is_super_user
+    , created_by_user_id
+    , updated_last_by_user_id
+    , change_set_id
+)
+VALUES
+      (
+        'Tierney'
+        , 'Gullen'
+        , 'tierneybailey13@gmail.com'
+        , FALSE
+        , 3
+        , 3
+        , 27
+    )
+    , (
+        'Lliam'
+        , 'Rae'
+        , 'lliamevan7@gmail.com'
+        , FALSE
+        , 3
+        , 3
+        , 27
+    )
+    , (
+        'Bot'
+        , ''
+        , 'bot@partsltd.co.uk'
+        , FALSE
+        , 3
+        , 3
+        , 27
+    )
+    , (
+        'Guest'
+        , ''
+        , ''
+        , FALSE
+        , 3
+        , 3
+        , 27
+    )
+;
+
+-- Error type
+INSERT INTO tcg.public.Error_Type (
+      code
+    , name
+    , active
+    , created_by_user_id
+    , updated_last_by_user_id
+    , change_set_id
+)
+VALUES
+      (
+          'BAD_DATA'
+        , 'Invalid data'
+        , TRUE
+        , 3
+        , 3
+        , 10
+    )
+    , (
+          'NO_PERMISSION'
+        , 'No permission'
+        , TRUE
+        , 3
+        , 3
+        , 10
+    )
+    , (
+          'SQL_ERROR'
+        , 'SQL Error'
+        , TRUE
+        , 3
+        , 3
+        , 10
+    )
+    , (
+          'WARNING'
+        , 'Warning'
+        , TRUE
+        , 3
+        , 3
+        , 10
+    )
+;
+
+-- Condition
+INSERT INTO tcg.public.TCG_Condition (
+	name
+	, code
+	, description
+	, summary
+	, us_name
+    , change_set_id
+    , created_by_user_id
+    , updated_last_by_user_id
+)
+VALUES
+	(
+	'Mint' -- name
+	, 'M' -- code
+	, $$A mint card is in perfect condition; no excuses. This means, that the front is in perfect condition, there are no scratches on the surface, and the surface is perfectly clean. For the back it means, that the card is indistinguishable from cards of a newly openend booster. If a card has a signature or a Grand Prix stamp it can never be graded Mint, even if the card stock is otherwise in Mint condition.
+In most cases it doesn't make sense to grade a card as Mint. For newer cards, the value of a Mint card is basically the same as a Near Mint card. Older cards (1993-96), however, may command a high premium if they are in actual Mint condition - usually professionally graded. Thus 'Mint' is mainly a grading for cards where there is a high collectors' interest or a high professional grade. For cards that are sold mostly for playing purpose, a Near Mint grade is a safer choice.$$ -- description
+	, 'Perfect' -- summary
+	, 'Mint' -- us_name
+    , 1 -- change_set_id
+    , 3 -- created_by_user_id
+    , 3 -- updated_last_by_user_id
+	)
+	, (
+	'Near Mint' -- name
+	, 'NM' -- code
+	, $$A Near Mint card looks like it has never been played without sleeves. Small allowances can be made, but the card generally shows no wear.
+The border of NM card can have small white spots, but they must be very few and very small. When the card is inspected under bright daylight, the surface must generally appear clean. It can have a few minor spots, but scratches can never be allowed for NM cards.
+Generally a Near Mint card is in a condition that would make it considered unmarked if played in an unsleeved deck. (Not recommended!)
+As the Mint grade is often not used for cards of newer expansions, Near Mint usually means Near Mint or better (equivalent to the American NM/M grade).$$ -- description
+	, 'Booster-Fresh' -- summary
+	, 'Near Mint' -- us_name
+    , 1 -- change_set_id
+    , 3 -- created_by_user_id
+    , 3 -- updated_last_by_user_id
+	)
+	, (
+	'Excellent' -- name
+	, 'EX' -- code
+	, $$An Excellent cards look like it was used for a few games without sleeves. For Excellent cards it is almost always clearly visible upon first inspection that the card is not in perfect condition. However, although the damage is clearly visible it is only of minor severity.
+Excellent cards usually have a couple of white spots at the corners or around the border. The surface may have minor scratches, that are visible upon closer inspection. However, the card cannot be graded Excellent if the creases are so deep that they are visible upon first sight.
+An Excellent card is usually in a condition where it is not quite clear if the card would be considered marked or unmarked if it would be played in a tournament without sleeves.
+The American equivalent usually is Slightly Played or Lightly Played (not to be confused with the European Light Played).$$ -- description
+	, 'Minor-Wear' -- summary
+	, 'Slightly Played' -- us_name
+    , 1 -- change_set_id
+    , 3 -- created_by_user_id
+    , 3 -- updated_last_by_user_id
+	)
+	, (
+	'Good' -- name
+	, 'GD' -- code
+	, $$A Good card looks like it might have been used for a long tournament without sleeves.
+Cards in Good condition usually show strong wear all around the card. The edges and corners have many white spots, the surface usually has scratches and the card usually has accumulated some dirt on its surface. However, the card still only has damage that stems from regular play. The card has no water damage or bends whatsoever.
+A Good card (and all cards in worse condition) are clearly in a condition that would make them ineligible for play without sleeves as they would be considered marked.
+The American equivalent to this is usually 'Moderately Played' or 'Very Good'. Note that 'Good' is a bit of a misnomer. A Good card doesn't really look good. In fact it looks pretty beat up, making the American Very Good even more of a misnomer.$$ -- description
+	, 'Visible-Wear' -- summary
+	, 'Moderately Played' -- us_name
+    , 1 -- change_set_id
+    , 3 -- created_by_user_id
+    , 3 -- updated_last_by_user_id
+	)
+	, (
+	'Light Played' -- name
+	, 'LP' -- code
+	, $$A Light Played card looks as if it has been used without sleeves for an extended period of time.
+A Light Played card is clearly legal for play in a sleeved deck. It has also not been tampered with (inked border, random scribblings on the card etc.). If both of these criteria apply the card may look very bad, but it can be graded Light Played.
+The American equivalent usually is 'Played' or 'Good'.$$ -- description
+	, 'Severe-Wear' -- summary
+	, 'Played' -- us_name
+    , 1 -- change_set_id
+    , 3 -- created_by_user_id
+    , 3 -- updated_last_by_user_id
+	)
+	, (
+	'Played' -- name
+	, 'PL' -- code
+	, $$A Played card looks as bad as you can get a card through regular use without sleeves.
+A Played card looks extremely bad, and it is doubtful if the card is tournament legal even in a sleeved deck. However, the card has not been tampered with otherwise (inked border, random scribblings on the card etc.).
+The American equivalent usually is Heavily Played or Good.$$ -- description
+	, 'Damaged' -- summary
+	, 'Heavily Played' -- us_name
+    , 1 -- change_set_id
+    , 3 -- created_by_user_id
+    , 3 -- updated_last_by_user_id
+	)
+	, (
+	'Poor' -- name
+	, 'PO' -- code
+	, $$A Poor card has damage that cannot normally have stemmed from regular use of the card.
+A card in Poor condition is literally destroyed. It is either obviously illegal for tournament play or has been tampered with in ways that destroy its worth almost completely (inked border, random scribblings on the card etc.).
+Americans usually use Poor in the same way.$$ -- description
+	, 'Destroyed' -- summary
+	, 'Poor' -- us_name
+    , 1 -- change_set_id
+    , 3 -- created_by_user_id
+    , 3 -- updated_last_by_user_id
+	)
+;
+
+'
+
+-- MTG Finish
+INSERT INTO tcg.public.TCG_MTG_Finish (
+	name
+	, description
+    , change_set_id
+    , created_by_user_id
+    , updated_last_by_user_id
+)
+VALUES
+    (
+          'Standard' -- name
+        , '' -- description
+        , 1 -- change_set_id
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+    )
+    , (
+          'Foil' -- name
+        , '' -- description
+        , 1 -- change_set_id
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+    )
+    , (
+          'Etched Foil' -- name
+        , '' -- description
+        , 1 -- change_set_id
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+    )
+    , (
+          'Borderless' -- name
+        , '' -- description
+        , 1 -- change_set_id
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+    )
+    , (
+          'Extended Art' -- name
+        , '' -- description
+        , 1 -- change_set_id
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+    )
+    , (
+          'Showcase' -- name
+        , '' -- description
+        , 1 -- change_set_id
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+    )
+;
+
+-- Inventory
+SELECT I_T.temp_id -- COUNT(*)
+	, I_T.name
+	, MAIN_CARD.name
+	, I_T.set_code
+	, MAIN_CARD.SET
+	, I_T.collector_number 
+	, MAIN_CARD.collector_number 
+	, MAIN_CARD.set_type
+	, I_T.display_order
+	, I_T.token_rear_side_name
+	, REAR_CARD.name AS rear_name
+	, I_T.token_rear_side_set_code
+	, REAR_CARD.SET AS rear_set
+	, I_T.token_rear_side_collector_number 
+	, REAR_CARD.collector_number AS rear_collector_number
+	, REAR_CARD.set_type AS rear_set_type
+FROM tcg.public.TCG_MTG_Inventory_Temp I_T
+LEFT JOIN tcg.public.TCG_MTG_Card MAIN_CARD
+    ON  (
+    		(
+	    		I_T.is_token = FALSE
+			AND LOWER(I_T.set_code) = MAIN_CARD.SET
+		)
+        OR  (
+        		I_T.is_token = TRUE
+        	AND MAIN_CARD.set_type = 'token'
+        	AND 't' || LOWER(I_T.set_code) = MAIN_CARD.set
+        )
+        /*
+        OR  (
+                I_T.set_code LIKE 'FIN%'
+            AND C.set = 'fin'
+        )
+        */
+    )
+    AND I_T.collector_number = MAIN_CARD.collector_number
+LEFT JOIN tcg.public.TCG_MTG_Card REAR_CARD
+    ON  (
+    		(
+	    		I_T.is_token = FALSE
+			AND LOWER(I_T.set_code) = REAR_CARD.SET
+		)
+        OR  (
+        		I_T.is_token = TRUE
+        	AND REAR_CARD.set_type = 'token'
+        	AND 't' || LOWER(I_T.set_code) = REAR_CARD.set
+        )
+    )
+    AND I_T.collector_number = REAR_CARD.collector_number
+WHERE -- 1=1 OR
+	
+		MAIN_CARD.card_id IS NULL
+	-- OR  C.name <> I_T.name
+	-- OR	C.set_type = 'token'
+	OR (
+			I_T.is_token = TRUE
+		AND REAR_CARD.card_id IS NULL
+	)
+	-- I_T.name = 'Idyllic Beachfront'
+-- GROUP BY I_T.temp_id
+ORDER BY I_T.display_order
+;
+
+SELECT -- *
+	C.name
+	, C.set
+	, C.collector_number 
+	, *
+FROM tcg.public.TCG_MTG_Card C
+WHERE
+-- 		C.name LIKE 'Dragon Illusion'
+		C.set = 'tdm'
+	AND C.collector_number = '294'
+ORDER BY C.set, C.collector_number 
+;
+
+
+INSERT INTO tcg.public.TCG_MTG_Inventory (
+	  card_id
+    , finish_id
+    , condition_id
+    , sleeve_colour_name
+    , location_name
+    , acquired_from
+    , acquired_on
+    , cost_gbp
+    , sale_price_gbp
+    , is_sold
+    , is_destroyed
+    , notes
+    , alterations_customisations
+    , grading_company_name
+    , grading_score
+    , subgrades
+    , misprint_errors
+    , miscut_errors
+    , playability
+    , owner_user_id
+    , ownership_status_name
+    , trading_status_name
+    , loaned_to_user_id
+    , loan_start_on
+    , loan_end_on
+    , provenance
+    , signed_by_names
+    , signature_condition_name
+    , active
+	, created_by_user_id
+	, updated_last_by_user_id
+    , change_set_id
+    
+    , token_rear_side_card_id
+)
+SELECT
+	  MAIN_CARD.card_id
+    , I_T.finish_id
+    , I_T.condition_id
+    , I_T.sleeve_colour_name
+    , I_T.location_name
+    , I_T.acquired_from
+    , I_T.acquired_on
+    , I_T.cost_gbp
+    , I_T.sale_price_gbp
+    , I_T.is_sold
+    , I_T.is_destroyed
+    , I_T.notes
+    , I_T.alterations_customisations
+    , I_T.grading_company_name
+    , I_T.grading_score
+    , I_T.subgrades
+    , I_T.misprint_errors
+    , I_T.miscut_errors
+    , I_T.playability
+    , I_T.owner_user_id
+    , I_T.ownership_status_name
+    , I_T.trading_status_name
+    , I_T.loaned_to_user_id
+    , I_T.loan_start_on
+    , I_T.loan_end_on
+    , I_T.provenance
+    , I_T.signed_by_names
+    , I_T.signature_condition_name
+    , I_T.active
+	, I_T.created_by_user_id
+	, I_T.updated_last_by_user_id
+    , I_T.change_set_id
+    
+    , REAR_CARD.card_id
+FROM tcg.public.TCG_MTG_Inventory_Temp I_T
+INNER JOIN tcg.public.TCG_MTG_Card MAIN_CARD
+    ON  (
+    		(
+	    		I_T.is_token = FALSE
+			AND LOWER(I_T.set_code) = MAIN_CARD.SET
+		)
+        OR  (
+        		I_T.is_token = TRUE
+        	AND MAIN_CARD.set_type = 'token'
+        	AND 't' || LOWER(I_T.set_code) = MAIN_CARD.set
+        )
+        /*
+        OR  (
+                I_T.set_code LIKE 'FIN%'
+            AND C.set = 'fin'
+        )
+        */
+    )
+    AND I_T.collector_number = MAIN_CARD.collector_number
+LEFT JOIN tcg.public.TCG_MTG_Card REAR_CARD
+    ON  (
+    		(
+	    		I_T.is_token = FALSE
+			AND LOWER(I_T.set_code) = REAR_CARD.SET
+		)
+        OR  (
+        		I_T.is_token = TRUE
+        	AND REAR_CARD.set_type = 'token'
+        	AND 't' || LOWER(I_T.set_code) = REAR_CARD.set
+        )
+    )
+    AND I_T.collector_number = REAR_CARD.collector_number
+ORDER BY I_T.display_order
+;
+-- SELECT * FROM tcg.public.TCG_MTG_Inventory_Temp;
+SELECT
+	-- I.inventory_id
+	C.card_id
+	, C.name
+	, C.card_faces
+FROM /* tcg.public.TCG_MTG_Inventory I
+INNER JOIN*/  tcg.public.TCG_MTG_Card C -- ON I.card_id = C.card_id
+WHERE 
+	-- C.name LIKE '%Yuna%'
+		C.set_type = 'token'
+	-- AND C.card_faces LIKE '%name'': ''Treasure'
+	AND C.name IN ('Treasure', 'Clue')
+ORDER BY C.card_id -- I.inventory_id
+;
+
+SELECT 
+	C.set
+	, C.collector_number
+	, COUNT(*)
+FROM tcg.public.TCG_MTG_Card C
+GROUP BY 
+	C.set
+	, C.collector_number
+HAVING COUNT(*) > 1
+;
+
+
+
+
+-- Deck Lookup Tables
+INSERT INTO tcg.public.TCG_MTG_Deck_Commander_Bracket (
+	name
+    , description
+    , display_order
+    , created_by_user_id
+    , updated_last_by_user_id
+    , change_set_id
+)
+VALUES 
+    (
+          'Exhibition' -- name
+        , $$Throw down with your ultra-casual Commander deck!
+
+Winning is not the primary goal here, as it's more about showing off something unusual you've made. Villains yelling in the art? Everything has the number four? Oops, all Horses? Those are all fair game! The games here are likely to go long and end slowly.
+
+Just focus on having fun and enjoying what the table has brought!
+
+Deck Building: No cards from the Game Changers list. No intentional two-card infinite combos, mass land denial, or extra-turn cards. Tutors should be sparse.$$ -- description
+        , 1
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+        , 1 -- change_set_id
+    )
+    , (
+          'Core' -- name
+        , $$The easiest reference point is that the average current preconstructed deck is at a Core (Bracket 2) level.
+
+While Bracket 2 decks may not have every perfect card, they have the potential for big, splashy turns, strong engines, and are built in a way that works toward winning the game. While the game is unlikely to end out of nowhere and generally goes nine or more turns, you can expect big swings. The deck usually has some cards that aren't perfect from a gameplay perspective but are there for flavor reasons, or just because they bring a smile to your face.
+
+Deck Building: No cards from the Game Changers list. No intentional two-card infinite combos or mass land denial. Extra-turn cards should only appear in low quantities and are not intended to be chained in succession or looped. Tutors should be sparse.$$ -- description
+        , 2
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+        , 1 -- change_set_id
+    )
+    , (
+          'Upgraded' -- name
+        , $$These decks are souped up and ready to play beyond the strength of an average preconstructed deck.
+
+They are full of carefully selected cards, with work having gone into figuring out the best card for each slot. The games tend to be a little faster as well, ending a turn or two sooner than your Core (Bracket 2) decks. This also is where players can begin playing up to three cards from the Game Changers list, amping up the decks further. Of course, it doesn't have to have any Game Changers to be a Bracket 3 deck: many decks are more powerful than a preconstructed deck, even without them!
+
+These decks should generally not have any two-card infinite combos that can happen cheaply and in about the first six or so turns of the game, but it's possible the long game could end with one being deployed, even out of nowhere.
+
+Deck Building: Up to three cards from the Game Changers list. No intentional early-game two-card infinite combos. Extra-turn cards should only appear in low quantities and are not intended to be chained in succession or looped. No mass land denial.$$ -- description
+        , 3
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+        , 1 -- change_set_id
+    )
+    , (
+          'Optimized' -- name
+        , $$It's time to go wild!
+
+Bring out your strongest decks and cards. You can expect to see explosive starts, strong tutors, cheap combos that end games, mass land destruction, or a deck full of cards off the Game Changers list. This is high-powered Commander, and games have the potential to end quickly.
+
+The focus here is on bringing the best version of the deck you want to play, but not one built around a tournament metagame. It's about shuffling up your strong and fully optimized deck, whatever it may be, and seeing how it fares. For most Commander players, these are the highest-power Commander decks you will interact with.
+
+Deck Building: There are no restrictions (other than the banned list).$$ -- description
+        , 4
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+        , 1 -- change_set_id
+    )
+    , (
+          'cEDh' -- name
+        , $$This is high power with a very competitive and metagame-focused mindset.
+
+"Mindset" is a key part of that description: Much of it is in how you approach the format and deck building. It's not just no holds barred, where you play your most powerful cards like in Bracket 4. It requires careful planning: There is care paid into following and paying attention to a metagame and tournament structure, and no sacrifices are made in deck building as you try to be the one to win the pod. Additionally, there is special care and attention paid to behavior and tableside negotiation (such as not making spite plays or concessions) that play into the tournament structure.
+
+cEDH, or "competitive Commander" and similar names, is where winning matters more than self-expression. You might not be playing your favorite cards or commanders, as pet cards are usually replaced with cards needed in the meta, but you're playing what you think will be most likely to win.
+
+Deck Building: There are no restrictions (other than the banned list).
+$$ -- description
+        , 5
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+        , 1 -- change_set_id
+    )
+;
+
+'
+
+INSERT INTO tcg.public.TCG_MTG_Deck (
+	  name
+    , commander_bracket_id
+    , created_by_user_id
+    , updated_last_by_user_id
+    , change_set_id
+)
+VALUES 
+    (
+          'Final Fantasy: Counter Blitz' -- name
+        , 2 -- commander_bracket_id
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+        , 1 -- change_set_id
+    )
+    , (
+          'Tarkir Dragonstorm: Jeskai Striker' -- name
+        , 2 -- commander_bracket_id
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+        , 1 -- change_set_id
+    )
+    , (
+          'The Lost Caverns of Ixalan: Blood Rites' -- name
+        , 2 -- commander_bracket_id
+        , 3 -- created_by_user_id
+        , 3 -- updated_last_by_user_id
+        , 1 -- change_set_id
+    )
+;
+
+
+SELECT *
+FROM tcg.public.TCG_MTG_Deck D
+;
+
+INSERT INTO tcg.public.TCG_MTG_Deck_Inventory_Link (
+    deck_id
+    , inventory_id
+    , display_order
+    , created_by_user_id
+    , updated_last_by_user_id
+    , change_set_id
+)
+SELECT
+    CASE WHEN C.set LIKE '%fic' OR C.set LIKE '%fin' THEN 1 ELSE 2 END AS deck_id
+    , I.inventory_id
+    , CASE WHEN C.set LIKE '%fic' OR C.set LIKE '%fin' THEN I.inventory_id ELSE I.inventory_id - 106 END AS display_order
+    , 3 -- created_by_user_id
+    , 3 -- updated_last_by_user_id
+    , 1 -- change_set_id
+FROM tcg.public.TCG_MTG_Inventory I
+INNER JOIN tcg.public.TCG_MTG_Card C ON I.card_id = C.card_id
+ORDER BY I.inventory_id
+;
+
+INSERT INTO tcg.public.TCG_Change_Set (
+	comment
+	, updated_last_by_user_id
+)
+VALUES (
+	'Remove extra cards from Tarkir Dragonstorm deck.'
+	, 3
+);
+
+UPDATE tcg.public.TCG_MTG_Deck_Inventory_Link DIL
+SET 
+	  active = FALSE
+	, change_set_id = 6
+WHERE DIL.inventory_id IN (217, 218)
+;

static/PostgreSQL/99150_qry_unowned_land.sql

@@ -0,0 +1,93 @@
+-- Unowned Land
+
+WITH
+	  Cleaned_Card AS (
+		SELECT
+		      C.card_id
+			, C.name
+		    , C.type_line
+		    , C.oracle_text
+		    , C.color_identity
+		    , C.produced_mana
+		    , COALESCE(C.price_eur, C.price_usd, C.price_tix) AS price
+		FROM tcg.public.TCG_MTG_Card C
+	)
+    , Owned_Card AS (
+        SELECT C.name
+        FROM tcg.public.TCG_MTG_Card C
+        INNER JOIN tcg.public.TCG_MTG_Inventory I ON C.card_id = I.card_id
+    )
+    , Unowned_Land AS (
+        SELECT
+              CC.card_id
+            , CC.name
+            , ROW_NUMBER() OVER (
+                PARTITION BY 
+                	  CC.name
+                	, CC.oracle_text 
+                ORDER BY 
+                	  CC.price NULLS LAST
+					, CC.type_line
+                	, CC.card_id
+              ) AS index_card_price_in_card_reprints
+        FROM Cleaned_Card CC
+        LEFT JOIN Owned_Card OC ON CC.name = OC.name
+        WHERE
+                OC.name IS NULL
+            AND CC.type_line LIKE '%Land%'
+    )
+SELECT
+	-- COUNT(*)
+	-- MAX(COALESCE(CC.price, 0.0))
+      CC.name
+    , CC.type_line
+    , REPLACE(CC.name, ' ', '+')
+    , CC.oracle_text
+    , CONCAT(
+    	  'https://magicmadhouse.co.uk/search.php?search_query='
+    	, REPLACE(CC.name, ' ', '+')
+    	, '&Filters=brand%3AMagic%253A%2520The%2520Gathering'
+    ) AS url_mm
+    , CONCAT(
+    	  'https://www.chaoscards.co.uk/search/'
+    	, REPLACE(CC.name, ' ', '+')
+    	, '?sort=price_asc&in_stock=In+stock&brand=Magic+the+Gathering'
+    ) AS url_cc
+    , CONCAT(
+    	  'https://www.bigorbitcards.co.uk/magic-the-gathering/search/'
+    	, REPLACE(CC.name, ' ', '+')
+    	, '/?order=product.price.asc'
+    ) AS url_boc
+    , CC.color_identity
+    , CC.produced_mana
+    , CC.price
+FROM Cleaned_Card CC
+INNER JOIN Unowned_Land UL ON CC.card_id = UL.card_id
+WHERE 
+		UL.index_card_price_in_card_reprints = 1
+	AND ( -- Invalid colours
+			CC.color_identity NOT IN ('G, R', 'B, G', 'B, R', 'B, U')
+	)
+	AND CC.oracle_text NOT LIKE '%This land enters tapped unless you control a Mount or Vehicle.%'
+ORDER BY
+	  CC.price NULLS LAST
+	, CC.type_line
+	, CC.name
+	, CC.card_id
+-- LIMIT 250
+OFFSET 200
+;
+
+/*
+SELECT
+	  C.name
+	, C.set
+FROM tcg.public.TCG_MTG_Card C
+INNER JOIN tcg.public.TCG_MTG_Inventory I ON C.card_id = I.card_id
+WHERE UPPER(C.type_line) LIKE '%SOLDIER%'
+ORDER BY
+	  C.set
+	, C.name
+;
+*/
+

static/PostgreSQL/deprecated/11005_tbl_TCG_Language.sql

@@ -0,0 +1,16 @@
+CREATE TABLE tcg.public.TCG_Language (
+	  language_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, name TEXT NOT NULL 
+	, description TEXT NOT NULL
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_Language_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+    , change_set_id INT
+    , CONSTRAINT FK_TCG_Language_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/deprecated/11006_tbl_TCG_Language_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_Language_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, language_id INT NOT NULL
+	, CONSTRAINT FK_TCG_Language_Audit_language_id
+		FOREIGN KEY (language_id)
+		REFERENCES tcg.public.TCG_Language(language_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_Language_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/deprecated/11101_tbl_TCG_MTG_Rarity.sql

@@ -0,0 +1,19 @@
+CREATE TABLE tcg.public.TCG_MTG_Rarity (
+	  rarity_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, name TEXT NOT NULL 
+	, colour_name TEXT NOT NULL
+	, price_ratio_min DECIMAL(6, 1)
+	, price_ratio_max DECIMAL(6, 1)
+    , active BOOLEAN NOT NULL DEFAULT TRUE
+	, created_on TIMESTAMP NOT NULL
+	, created_by_user_id INT NOT NULL
+    , CONSTRAINT FK_TCG_MTG_Rarity_created_by_user_id
+        FOREIGN KEY (created_by_user_id)
+        REFERENCES tcg.public.TCG_User(user_id)
+	, updated_last_on TIMESTAMP
+	, updated_last_by_user_id INT
+    , change_set_id INT
+    , CONSTRAINT FK_TCG_MTG_Rarity_change_set_id
+		FOREIGN KEY (change_set_id)
+        REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/deprecated/11102_tbl_TCG_MTG_Rarity_Audit.sql

@@ -0,0 +1,15 @@
+
+CREATE TABLE tcg.public.TCG_MTG_Rarity_Audit (
+	  audit_id INT GENERATED ALWAYS AS IDENTITY PRIMARY KEY
+	, rarity_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Rarity_Audit_rarity_id
+		FOREIGN KEY (rarity_id)
+		REFERENCES tcg.public.TCG_MTG_Rarity(rarity_id)
+	, name_field TEXT NOT NULL
+	, value_prev TEXT
+	, value_new TEXT
+	, change_set_id INT NOT NULL
+	, CONSTRAINT FK_TCG_MTG_Rarity_Audit_change_set_id
+		FOREIGN KEY (change_set_id) 
+		REFERENCES tcg.public.TCG_Change_Set(change_set_id)
+);

static/PostgreSQL/deprecated/31101_tri_TCG_MTG_Rarity.sql

@@ -0,0 +1,68 @@
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Rarity()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.created_on = CURRENT_TIMESTAMP;
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF NEW.change_set_id IS NULL THEN
+		RAISE EXCEPTION 'Change Set ID must be provided.';
+    END IF;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE OR REPLACE FUNCTION tcg.public.FN_before_update_TCG_MTG_Rarity()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_last_on = CURRENT_TIMESTAMP;
+
+    IF OLD.change_set_id IS NOT DISTINCT FROM NEW.change_set_id THEN
+		RAISE EXCEPTION 'New Change Set ID must be provided.';
+    END IF;
+
+    INSERT INTO tcg.public.TCG_MTG_Rarity_Audit (
+		  rarity_id
+        , name_field
+        , value_prev
+        , value_new
+        , change_set_id
+    )
+	-- Changed name
+	SELECT NEW.rarity_id, 'name', OLD.name, NEW.name, NEW.change_set_id
+		WHERE OLD.name IS NOT DISTINCT FROM NEW.name
+	UNION
+	-- Changed colour_name
+	SELECT NEW.rarity_id, 'colour_name', OLD.colour_name, NEW.colour_name, NEW.change_set_id
+		WHERE OLD.colour_name IS NOT DISTINCT FROM NEW.colour_name
+	UNION
+	-- Changed price_ratio_min
+	SELECT NEW.rarity_id, 'price_ratio_min', OLD.price_ratio_min::TEXT, NEW.price_ratio_min::TEXT, NEW.change_set_id
+		WHERE OLD.price_ratio_min IS NOT DISTINCT FROM NEW.price_ratio_min
+	UNION
+	-- Changed price_ratio_max
+	SELECT NEW.rarity_id, 'price_ratio_max', OLD.price_ratio_max::TEXT, NEW.price_ratio_max::TEXT, NEW.change_set_id
+		WHERE OLD.price_ratio_max IS NOT DISTINCT FROM NEW.price_ratio_max
+	UNION
+	-- Changed active
+	SELECT NEW.rarity_id, 'active', OLD.active::TEXT, NEW.active::TEXT, NEW.change_set_id
+		WHERE OLD.active IS NOT DISTINCT FROM NEW.active
+    ;
+    
+    RETURN NEW;
+END;
+$$ LANGUAGE plpgsql
+;
+
+CREATE TRIGGER TRI_before_insert_TCG_MTG_Rarity
+    BEFORE INSERT ON tcg.public.TCG_MTG_Rarity
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_insert_TCG_MTG_Rarity()
+;
+CREATE TRIGGER TRI_before_update_TCG_MTG_Rarity
+    BEFORE UPDATE ON tcg.public.TCG_MTG_Rarity
+    FOR EACH ROW
+    EXECUTE FUNCTION tcg.public.FN_before_update_TCG_MTG_Rarity()
+;