เร่งการย้ายคลังข้อมูลของคุณไปยัง Amazon Redshift – ตอนที่ 3

CREATE TABLE testschema.employee( id INTEGER
, name VARCHAR(20)
, manager INTEGER)
UNIQUE PRIMARY INDEX (id)
; CREATE TABLE testschema.employee_delta ( id INTEGER
, name VARCHAR(20)
, manager INTEGER)
UNIQUE PRIMARY INDEX(id)
;

REPLACE MACRO testschema.merge_employees AS ( MERGE INTO testschema.employee tgt USING testschema.employee_delta delta ON delta.id = tgt.id WHEN MATCHED THEN UPDATE SET name = delta.name, manager = delta.manager WHEN NOT MATCHED THEN INSERT (delta.id, delta.name, delta.manager);
);

CREATE OR REPLACE PROCEDURE testschema.merge_employees()
AS $BODY$
BEGIN UPDATE testschema.employee SET name = "delta".name, manager = "delta".manager FROM testschema.employee_delta AS delta JOIN testschema.employee AS tgt ON "delta".id = tgt.id; INSERT INTO testschema.employee SELECT "delta".id , "delta".name , "delta".manager FROM testschema.employee_delta AS delta WHERE NOT EXISTS ( SELECT 1 FROM testschema.employee AS tgt WHERE "delta".id = tgt.id );
END;
$BODY$
LANGUAGE plpgsql;

CREATE TABLE testschema.char_table ( id INTEGER
, char_col CHAR(10)
, varchar_col VARCHAR(10)
); INSERT INTO testschema.char_table VALUES (1, 'Hello', 'world');

# SELECT id, char_col, ascii(char_col), varchar_col, ascii(varchar_col) FROM testschema.char_table; id | char_col | ascii | varchar_col | ascii 1 | Hello | 72 | world | 119

# SELECT to_date('2021-06-31', 'YYYY-MM-DD'); to_date 2021-07-01
(1 row)

# SELECT to_date('2021-06-31', 'YYYY-MM-DD', TRUE);
ERROR: date/time field date value out of range: 2021-6-31

# SELECT to_date('2021-06-31', 'YYYY-MM-DD', FALSE); to_date 2021-07-01
(1 row)

REPLACE PROCEDURE testschema.employee_cursor (IN p_mgrid INTEGER) DYNAMIC RESULT SETS 1
BEGIN DECLARE result_set CURSOR WITH RETURN ONLY FOR SELECT id, name, manager FROM testschema.employee WHERE manager = to_char(p_mgrid); OPEN result_set;
END;

CREATE OR REPLACE PROCEDURE testschema.employee_cursor(par_p_mgrid IN INTEGER, dynamic_return_cursor INOUT refcursor)
AS $BODY$
DECLARE
BEGIN OPEN dynamic_return_cursor FOR SELECT id, name, manager FROM testschema.employee WHERE manager = to_char(par_p_mgrid, '99999');
END;
$BODY$
LANGUAGE plpgsql;

CREATE TABLE testschema.identity_table ( a2 BIGINT GENERATED ALWAYS AS IDENTITY ( START WITH 1 INCREMENT BY 20 )
);

CREATE TABLE IF NOT EXISTS testschema.identity_table ( a2 BIGINT IDENTITY(1, 20)
)
DISTSTYLE KEY
DISTKEY
(a2)
SORTKEY
(a2);

# INSERT INTO testschema.identity_table VALUES (100);
ERROR: cannot set an identity column to a value

CREATE TABLE testschema.identity_by_default ( a1 BIGINT GENERATED BY DEFAULT AS IDENTITY ( START WITH 1 INCREMENT BY 20 )
PRIMARY INDEX (a1);

CREATE TABLE testschema.identity_by_default ( a1 BIGINT GENERATED BY DEFAULT AS IDENTITY(1,20) DISTKEY
) DISTSTYLE KEY SORTKEY (a1);

INSERT INTO identity_by_default VALUES (null);

INSERT INTO testschema.identity_by_default VALUES (default);

REPLACE MACRO testschema.insert_identity_by_default AS ( INSERT INTO testschema.identity_by_default VALUES (NULL);
);

CREATE OR REPLACE PROCEDURE testschema.insert_identity_by_default() LANGUAGE plpgsql
AS $$ BEGIN INSERT INTO testschema.identity_by_default VALUES (DEFAULT);
END; $$ 

REPLACE MACRO testschema.not_in_103 AS ( SELECT * FROM testschema.employee WHERE manager <> ANY (103)
;
);

CREATE OR REPLACE PROCEDURE testschema.not_in_103(macro_out INOUT refcursor)
AS $BODY$
BEGIN OPEN macro_out FOR SELECT * FROM testschema.employee WHERE ((manager <> 103));
END;
$BODY$
LANGUAGE plpgsql;

CREATE TABLE testschema.sales ( store_id INTEGER
, month_no INTEGER
, sales_amount DECIMAL(9,2)
)
; REPLACE VIEW testschema.running_total ( store_id
, month_no
, sales_amount
, cume_sales_amount
)
AS
SELECT store_id
, month_no
, sales_amount
, SUM(sales_amount) OVER ( PARTITION BY store_id ORDER BY month_no RESET WHEN sales_amount < SUM(sales_amount) OVER ( PARTITION BY store_id ORDER BY month_no ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING ) ROWS UNBOUNDED PRECEDING )
FROM testschema.sales;

INSERT INTO testschema.sales VALUES (1001, 1, 35000.00);
INSERT INTO testschema.sales VALUES (1001, 2, 40000.00);
INSERT INTO testschema.sales VALUES (1001, 3, 45000.00);
INSERT INTO testschema.sales VALUES (1001, 4, 25000.00);
INSERT INTO testschema.sales VALUES (1001, 5, 30000.00);
INSERT INTO testschema.sales VALUES (1001, 6, 30000.00);
INSERT INTO testschema.sales VALUES (1001, 7, 50000.00);
INSERT INTO testschema.sales VALUES (1001, 8, 35000.00);
INSERT INTO testschema.sales VALUES (1001, 9, 60000.00);
INSERT INTO testschema.sales VALUES (1001, 10, 80000.00);
INSERT INTO testschema.sales VALUES (1001, 11, 90000.00);
INSERT INTO testschema.sales VALUES (1001, 12, 100000.00);

SELECT * FROM testschema.running_total; store_id month_no sales_amount cume_sales_amount
----------- ----------- ------------ ----------------- 1001 1 35000.00 35000.00 1001 2 40000.00 75000.00 1001 3 45000.00 120000.00 1001 4 25000.00 25000.00 1001 5 30000.00 55000.00 1001 6 30000.00 85000.00 1001 7 50000.00 135000.00 1001 8 35000.00 35000.00 1001 9 60000.00 95000.00 1001 10 80000.00 175000.00 1001 11 90000.00 265000.00 1001 12 100000.00 365000.00

CREATE OR REPLACE VIEW testschema.running_total ( store_id
, month_no
, sales_amount
, cume_sales_amount) AS
SELECT store_id
, month_no
, sales_amount
, sum(sales_amount) OVER (PARTITION BY k1, store_id ORDER BY month_no NULLS FIRST ROWS UNBOUNDED PRECEDING)
FROM ( SELECT store_id , month_no , sales_amount , SUM(CASE WHEN k = 1 THEN 0 ELSE 1 END) OVER (PARTITION BY store_id ORDER BY month_no NULLS FIRST ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS k1 FROM ( SELECT store_id , month_no , sales_amount , CASE WHEN sales_amount < SUM(sales_amount) OVER (PARTITION BY store_id ORDER BY month_no ROWS BETWEEN 1 PRECEDING AND 1 PRECEDING) OR sales_amount IS NULL THEN 0 ELSE 1 END AS k FROM testschema.sales )
);

CREATE TABLE testschema.salaries ( emp_id INTEGER
, salary DECIMAL(8,2)
, from_to PERIOD(DATE)
);

SELECT * FROM testschema.salaries ORDER BY emp_id, from_to; emp_id salary from_to
----------- ---------- ------------------------ 1 1000.00 ('20/01/01', '20/05/31') 1 2000.00 ('20/06/01', '21/02/28') 1 2000.00 ('21/01/01', '21/06/30') 2 3000.00 ('20/01/01', '20/03/31') 2 3000.00 ('20/02/01', '20/04/30')

REPLACE VIEW testschema.normalize_salaries AS WITH sub_table(emp_id, salary, from_to) AS ( SELECT emp_id , salary , from_to FROM testschema.salaries
)
SELECT *
FROM TABLE(TD_SYSFNLIB.TD_NORMALIZE_OVERLAP (NEW VARIANT_TYPE(sub_table.emp_id, sub_table.salary), sub_table.from_to) RETURNS (emp_id INTEGER, salary DECIMAL(8,2), from_to PERIOD(DATE)) HASH BY emp_id LOCAL ORDER BY emp_id, salary, from_to ) AS DT(emp_id, salary, duration)
;

เราสามารถตรวจสอบว่าข้อมูลการดูถูกทำให้เป็นมาตรฐานจริงหรือไม่:

select * from testschema.normalize_salaries order by emp_id, duration; emp_id salary duration
----------- ---------- ------------------------ 1 1000.00 ('20/01/01', '20/05/31') 1 2000.00 ('20/06/01', '21/06/30') 2 3000.00 ('20/01/01', '20/04/30')

ตอนนี้คุณสามารถใช้ AWS SCT เพื่อแปลงคำสั่ง TD_NORMALIZE_OVERLAP ใดๆ ได้แล้ว ก่อนอื่นเราแปลงตารางเงินเดือนเป็น Amazon Redshift (ดู เร่งการย้ายคลังข้อมูลของคุณไปยัง Amazon Redshift – ตอนที่ 2 สำหรับรายละเอียดเกี่ยวกับระบบอัตโนมัติประเภทข้อมูลช่วงเวลา):

CREATE TABLE testschema.salaries ( emp_id integer distkey
, salary numeric(8,2) ENCODE az64
, from_to_begin date ENCODE az64
, from_to_end date ENCODE az64 ) DISTSTYLE KEY SORTKEY (emp_id); # SELECT * FROM testschema.salaries ORDER BY emp_id, from_to_begin; emp_id | salary | from_to_begin | from_to_end 1 | 1000.00 | 2020-01-01 | 2020-05-31 1 | 2000.00 | 2020-06-01 | 2021-02-28 1 | 2000.00 | 2021-01-01 | 2021-06-30 2 | 3000.00 | 2020-01-01 | 2020-03-31 2 | 3000.00 | 2020-02-01 | 2020-04-30

ตอนนี้เราใช้ AWS SCT เพื่อแปลงมุมมอง normalize_salaries AWS SCT เพิ่มคอลัมน์ที่เป็นจุดเริ่มต้นของกลุ่มแถวใหม่ จากนั้นจะสร้างแถวเดียวสำหรับแต่ละกลุ่มด้วยการประทับเวลาปกติ

CREATE VIEW testschema.normalize_salaries (emp_id, salary, from_to_begin, from_to_end) AS
WITH sub_table AS ( SELECT emp_id , salary , from_to_begin AS start_date , from_to_end AS end_date , CASE WHEN start_date <= lag(end_date) OVER (PARTITION BY emp_id, salary ORDER BY start_date, end_date) THEN 0 ELSE 1 END AS GroupStartFlag FROM testschema.salaries )
SELECT t2.emp_id
, t2.salary
, min(t2.start_date) AS from_to_begin
, max(t2.end_date) AS from_to_end
FROM ( SELECT emp_id , salary , start_date , end_date , sum(GroupStartFlag) OVER (PARTITION BY emp_id, salary ORDER BY start_date ROWS UNBOUNDED PRECEDING) AS GroupID FROM sub_table
) AS t2
GROUP BY t2.emp_id
, t2.salary
, t2.GroupID;

เราสามารถตรวจสอบว่ามุมมองที่แปลงแล้วส่งคืนข้อมูลที่ถูกทำให้เป็นมาตรฐานอย่างถูกต้อง:

# SELECT * FROM testschema.normalize_salaries ORDER BY emp_id; emp_id | salary | from_to_begin | from_to_end 1 | 1000.00 | 2020-01-01 | 2020-05-31 1 | 2000.00 | 2020-06-01 | 2021-06-30 2 | 3000.00 | 2020-01-01 | 2020-04-30

คุณสามารถลองใช้การแปลง TD_NORMALIZE_OVERLAP ใน AWS SCT รุ่นล่าสุดได้ ดาวน์โหลด ตอนนี้

ฟังก์ชัน TD_UNPIVOT()

ฟังก์ชัน TD_UNPIVOT จะแปลงคอลัมน์เป็นแถว โดยพื้นฐานแล้ว เราจะใช้แถวของเมตริกที่คล้ายคลึงกันในช่วงเวลาต่างๆ และสร้างแถวแยกสำหรับแต่ละเมตริก

ตัวอย่างเช่น พิจารณาตาราง Teradata ต่อไปนี้ ตารางจะบันทึกการเข้าชมของลูกค้าตามปีและเดือนสำหรับร้านคีออสก์ขนาดเล็ก:

CREATE TABLE TESTSCHEMA.kiosk_monthly_visits ( kiosk_id INTEGER
, year_no INTEGER
, jan_visits INTEGER
, feb_visits INTEGER
, mar_visits INTEGER
, apr_visits INTEGER
, may_visits INTEGER
, jun_visits INTEGER
, jul_visits INTEGER
, aug_visits INTEGER
, sep_visits INTEGER
, oct_visits INTEGER
, nov_visits INTEGER
, dec_visits INTEGER)
PRIMARY INDEX (kiosk_id);

เราแทรกข้อมูลตัวอย่างลงในตาราง:

INSERT INTO testschema.kiosk_monthly_visits VALUES (100, 2020, 1100, 1200, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000, 2100, 2200);

ต่อไป เราสร้างมุมมองที่ unpivotes ตารางเพื่อให้การเข้าชมรายเดือนปรากฏในแถวที่แยกจากกัน แถวเดียวในตาราง Pivot จะสร้าง 12 แถวในตารางที่ไม่มีการหมุน หนึ่งแถวต่อเดือน

REPLACE VIEW testschema.unpivot_kiosk_monthly_visits ( kiosk_id
, year_no
, month_name
, month_visits
)
AS
SELECT kiosk_id
, year_no
, month_name (FORMAT 'X(10)')
, month_visits
FROM TD_UNPIVOT ( ON (SELECT * FROM testschema.kiosk_monthly_visits) USING VALUE_COLUMNS ('month_visits') UNPIVOT_COLUMN('month_name') COLUMN_LIST( 'jan_visits' , 'feb_visits' , 'mar_visits' , 'apr_visits' , 'may_visits' , 'jun_visits' , 'jul_visits' , 'aug_visits' , 'sep_visits' , 'oct_visits' , 'nov_visits' , 'dec_visits' ) COLUMN_ALIAS_LIST ( 'jan' , 'feb' , 'mar' , 'apr' , 'may' , 'jun' , 'jul' , 'aug' , 'sep' , 'oct' , 'nov' , 'dec' )
) a;

เมื่อคุณเลือกจากมุมมอง ยอดขายรายเดือนจะแยกออกเป็น 12 แถวแยกกัน:

SELECT * FROM testschema.unpivot_monthly_sales; id yr mon mon_sales
----------- ----------- ---------- ----------
100 2021 jan 1100.00
100 2021 feb 1200.00
100 2021 mar 1300.00
100 2021 apr 1400.00
100 2021 may 1500.00
100 2021 jun 1600.00
100 2021 jul 1700.00
100 2021 aug 1800.00
100 2021 sep 1900.00
100 2021 oct 2000.00
100 2021 nov 2100.00
100 2021 dec 2200.00

ตอนนี้เราใช้ AWS SCT เพื่อแปลงมุมมองเป็น ANSI SQL ที่สามารถเรียกใช้บน Amazon Redshift การแปลงจะสร้างนิพจน์ตารางทั่วไป (CTE) เพื่อวางในแต่ละเดือนในแถวที่แยกจากกัน จากนั้นจะรวม CTE และแอตทริบิวต์ที่เหลือจากตารางสาระสำคัญเดิม

REPLACE VIEW testschema.unpivot_kiosk_monthly_visits (kiosk_id, year_no, month_name, month_visits) AS
WITH cols
AS (SELECT 'jan' AS col
UNION ALL
SELECT 'feb' AS col
UNION ALL
SELECT 'mar' AS col
UNION ALL
SELECT 'apr' AS col
UNION ALL
SELECT 'may' AS col
UNION ALL
SELECT 'jun' AS col
UNION ALL
SELECT 'jul' AS col
UNION ALL
SELECT 'aug' AS col
UNION ALL
SELECT 'sep' AS col
UNION ALL
SELECT 'oct' AS col
UNION ALL
SELECT 'nov' AS col
UNION ALL
SELECT 'dec' AS col)
SELECT t1.kiosk_id, t1.year_no, col AS "month_name", CASE col WHEN 'jan' THEN "jan_visits" WHEN 'feb' THEN "feb_visits" WHEN 'mar' THEN "mar_visits" WHEN 'apr' THEN "apr_visits" WHEN 'may' THEN "may_visits" WHEN 'jun' THEN "jun_visits" WHEN 'jul' THEN "jul_visits" WHEN 'aug' THEN "aug_visits" WHEN 'sep' THEN "sep_visits" WHEN 'oct' THEN "oct_visits" WHEN 'nov' THEN "nov_visits" WHEN 'dec' THEN "dec_visits" ELSE NULL END AS "month_visits" FROM testschema.kiosk_monthly_visits AS t1 CROSS JOIN cols WHERE month_visits IS NOT NULL;

คุณสามารถตรวจสอบว่ามุมมองที่แปลงแล้วให้ผลลัพธ์เหมือนกับเวอร์ชัน Teradata:

# SELECT * FROM testschema.unpivot_kiosk_monthly_visits; kiosk_id | year_no | month_name | month_visits 100 | 2020 | oct | 2000 100 | 2020 | nov | 2100 100 | 2020 | jul | 1700 100 | 2020 | feb | 1200 100 | 2020 | apr | 1400 100 | 2020 | aug | 1800 100 | 2020 | sep | 1900 100 | 2020 | jan | 1100 100 | 2020 | mar | 1300 100 | 2020 | may | 1500 100 | 2020 | jun | 1600 100 | 2020 | dec | 2200

คุณสามารถลองใช้การสนับสนุนการแปลงสำหรับ TD_UNPIVOT ใน รุ่นล่าสุด ของ AWS SCT

ฟังก์ชัน QUANTILE

QUANTILE คือฟังก์ชันการจัดอันดับ มันแบ่งอินพุตที่กำหนดเป็นจำนวนกลุ่มที่ระบุ โดยแต่ละกลุ่มมีสัดส่วนที่เท่ากันของประชากรทั้งหมด QUANTILE เป็นส่วนขยาย Teradata ที่เป็นกรรมสิทธิ์ของฟังก์ชัน NTILE ที่พบใน ANSI SQL

ตัวอย่างเช่น เราสามารถคำนวณควอร์ไทล์ของข้อมูลการเข้าชมรายเดือนโดยใช้มุมมอง Teradata ต่อไปนี้:

REPLACE VIEW testschema.monthly_visit_rank AS
SELECT kiosk_id
, year_no
, month_name
, month_visits
, QUANTILE(4, month_visits) qtile
FROM testschema.unpivot_kiosk_monthly_visits
;

เมื่อคุณเลือกจากมุมมอง ฟังก์ชัน QUANTILE จะคำนวณควอร์ไทล์และใช้เป็นแอตทริบิวต์ในเอาต์พุต:

SELECT * FROM monthly_visit_rank; kiosk_id year_no month_name month_visits qtile
----------- ----------- ---------- ------------ ----------- 100 2020 jan 1100 0 100 2020 feb 1200 0 100 2020 mar 1300 0 100 2020 apr 1400 1 100 2020 may 1500 1 100 2020 jun 1600 1 100 2020 jul 1700 2 100 2020 aug 1800 2 100 2020 sep 1900 2 100 2020 oct 2000 3 100 2020 nov 2100 3 100 2020 dec 2200 3

Amazon Redshift รองรับฟังก์ชัน NTILE ทั่วไป ซึ่งสามารถใช้ QUANTILE และสอดคล้องกับ ANSI เราได้ปรับปรุง AWS SCT เพื่อแปลงการเรียกใช้ฟังก์ชัน QUANTILE เป็นการเรียกใช้ฟังก์ชัน NTILE ที่เทียบเท่าโดยอัตโนมัติ

ตัวอย่างเช่น เมื่อคุณแปลงมุมมอง Teradata ก่อนหน้านี้ AWS SCT จะสร้างโค้ด Amazon Redshift ต่อไปนี้:

SELECT unpivot_kiosk_monthly_visits.kiosk_id
, unpivot_kiosk_monthly_visits.year_no
, unpivot_kiosk_monthly_visits.month_name
, unpivot_kiosk_monthly_visits.month_visits
, ntile(4) OVER (ORDER BY unpivot_kiosk_monthly_visits.month_visits ASC NULLS FIRST) - 1) AS qtile FROM testschema.unpivot_kiosk_monthly_visits
;

รองรับการแปลง QUANTILE แล้วใน AWS SCT.

ตัวกรองคุณภาพ

ส่วนคำสั่ง QUALIFY ใน Teradata จะกรองแถวที่สร้างโดยฟังก์ชันการวิเคราะห์ ลองดูตัวอย่าง เราใช้ตารางต่อไปนี้ซึ่งมีรายรับจากร้านค้าตามเดือน เป้าหมายของเราคือการหาห้าเดือนแรกตามรายได้:

CREATE TABLE testschema.sales ( store_id INTEGER
, month_no INTEGER
, sales_amount DECIMAL(9,2))
PRIMARY INDEX (store_id); SELECT * FROM sales; store_id month_no sales_amount
----------- ----------- ------------ 1001 1 35000.00 1001 2 40000.00 1001 3 45000.00 1001 4 25000.00 1001 5 30000.00 1001 6 30000.00 1001 7 50000.00 1001 8 35000.00 1001 9 60000.00 1001 10 80000.00 1001 11 90000.00 1001 12 100000.00

ข้อมูลแสดงให้เห็นว่าเดือนกรกฎาคม กันยายน ตุลาคม พฤศจิกายน และธันวาคม เป็นเดือนที่มียอดขายสูงสุด XNUMX อันดับแรก

เราสร้างมุมมองที่ใช้ฟังก์ชัน RANK เพื่อจัดอันดับในแต่ละเดือนตามยอดขาย จากนั้นใช้ฟังก์ชัน QUALIFY เพื่อเลือกห้าเดือนแรก:

REPLACE VIEW testschema.top_five_months( store_id
, month_no
, sales_amount
, month_rank
) as
SELECT store_id
, month_no
, sales_amount
, RANK() OVER (PARTITION BY store_id ORDER BY sales_amount DESC) month_rank
FROM testschema.sales
QUALIFY RANK() OVER (PARTITION by store_id ORDER BY sales_amount DESC) <= 5
;

ก่อนหน้านี้ หากคุณใช้ส่วนคำสั่ง QUALIFY คุณต้องเข้ารหัสคำสั่ง SQL ของคุณใหม่ด้วยตนเอง ตอนนี้ AWS SCT จะแปลง QUALIFY เป็น SQL ที่เข้ากันได้กับ Amazon Redshift และสอดคล้องกับ ANSI โดยอัตโนมัติ ตัวอย่างเช่น AWS SCT จะเขียนมุมมองก่อนหน้าใหม่ดังนี้:

CREATE OR REPLACE VIEW testschema.top_five_months ( store_id
, month_no
, sales_amount
, month_rank) AS
SELECT qualify_subquery.store_id
, qualify_subquery.month_no
, qualify_subquery.sales_amount
, month_rank
FROM ( SELECT store_id , month_no , sales_amount , rank() OVER (PARTITION BY store_id ORDER BY sales_amount DESC NULLS FIRST) AS month_rank , rank() OVER (PARTITION BY store_id ORDER BY sales_amount DESC NULLS FIRST) AS qualify_expression_1 FROM testschema.sales) AS qualify_subquery WHERE qualify_expression_1 <= 5;

AWS SCT แปลงการสืบค้นต้นฉบับเป็นแบบสอบถามย่อย และใช้นิพจน์ QUALIFY เป็นตัวกรองในแบบสอบถามย่อย AWS SCT เพิ่มคอลัมน์เพิ่มเติมในแบบสอบถามย่อยเพื่อวัตถุประสงค์ในการกรอง ไม่จำเป็นอย่างยิ่ง แต่ช่วยลดความซับซ้อนของรหัสเมื่อไม่ใช้นามแฝงของคอลัมน์

คุณสามารถลองแปลง QUALIFY ใน รุ่นล่าสุด ของ AWS SCT

สรุป

เรายินดีที่จะแบ่งปันคุณลักษณะใหม่เหล่านี้กับคุณ หากคุณกำลังพิจารณาการย้ายข้อมูลไปยัง Amazon Redshift ความสามารถเหล่านี้สามารถช่วยให้การแปลงสคีมาของคุณเป็นแบบอัตโนมัติ และรักษาการลงทุนของคุณในรายงานและแอปพลิเคชันที่มีอยู่ หากคุณต้องการเริ่มต้นการย้ายคลังข้อมูล คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับ Amazon Redshift และ AWS SCT ได้จากเอกสารสาธารณะของเรา

โพสต์นี้อธิบายคุณสมบัติใหม่สองสามสิบอย่างที่เรากำลังแนะนำเพื่อทำให้การย้าย Teradata ของคุณไปยัง Amazon Redshift เป็นไปโดยอัตโนมัติ เราจะแชร์เพิ่มเติมในโพสต์ที่กำลังจะถึงเกี่ยวกับระบบอัตโนมัติสำหรับคุณสมบัติ Teradata ที่เป็นกรรมสิทธิ์และความสามารถใหม่ที่น่าตื่นเต้นอื่นๆ

โปรดกลับมาตรวจสอบอีกครั้งในเร็วๆ นี้สำหรับข้อมูลเพิ่มเติม ก่อนหน้านั้น คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับ อเมซอน Redshift และ เครื่องมือแปลงสคีมาของ AWS. ย้ายถิ่นอย่างมีความสุข!

เกี่ยวกับผู้เขียน

ไมเคิล ซู เป็นวิศวกรฐานข้อมูลอาวุโสกับทีม AWS Database Migration Service เขาสร้างผลิตภัณฑ์และบริการที่ช่วยให้ลูกค้าย้ายปริมาณงานฐานข้อมูลไปยัง AWS Cloud

ราซ่า ฮาฟีซ เป็นสถาปนิกข้อมูลภายใน Lake House Global Specialty Practice ของ AWS Professional Services เขามีประสบการณ์ระดับมืออาชีพมากกว่า 10 ปีในการสร้างและเพิ่มประสิทธิภาพคลังข้อมูลขององค์กร และมีความกระตือรือร้นในการทำให้ลูกค้าตระหนักถึงพลังของข้อมูลของตน เขาเชี่ยวชาญในการย้ายคลังข้อมูลขององค์กรไปยัง AWS Lake House Architecture

โพฮง, ปริญญาเอก, เป็นหัวหน้าสถาปนิกข้อมูลของ Lake House Global Specialty Practice, AWS Professional Services เขาหลงใหลในการสนับสนุนลูกค้าในการนำโซลูชันที่เป็นนวัตกรรมมาใช้เพื่อลดเวลาในการทำความเข้าใจ Po มีความเชี่ยวชาญในการย้ายคลังข้อมูลภายในองค์กรของ MPP ขนาดใหญ่ไปยังสถาปัตยกรรม AWS Lake House

เอนทง เสิน เป็นผู้จัดการฝ่ายพัฒนาซอฟต์แวร์ของ Amazon Redshift เขาทำงานเกี่ยวกับฐานข้อมูล MPP มานานกว่า 9 ปี และมุ่งเน้นไปที่การเพิ่มประสิทธิภาพการสืบค้น สถิติ และคุณสมบัติภาษา SQL ที่เกี่ยวข้องกับการย้ายข้อมูล เช่น กระบวนงานที่เก็บไว้และประเภทข้อมูล

สุมิตรสิงห์ เป็นวิศวกรฐานข้อมูลกับทีมบริการย้ายฐานข้อมูลที่ Amazon Web Services เขาทำงานอย่างใกล้ชิดกับลูกค้าและให้ความช่วยเหลือทางเทคนิคเพื่อย้ายปริมาณงานในองค์กรไปยัง AWS Cloud เขายังช่วยปรับปรุงคุณภาพและการทำงานของผลิตภัณฑ์การย้ายข้อมูล AWS อย่างต่อเนื่อง

เนลลี ซูซานโต เป็นผู้เชี่ยวชาญด้านการย้ายฐานข้อมูลอาวุโสของ AWS Database Migration Accelerator เธอมีพื้นฐานทางเทคนิคมากกว่า 10 ปี โดยมุ่งเน้นที่การโยกย้ายและการจำลองฐานข้อมูลพร้อมกับปริมาณงานคลังข้อมูล เธอหลงใหลในการช่วยเหลือลูกค้าในการเดินทางบนระบบคลาวด์