Teradata 简明教程

INSERT INTO <tablename>
(column1, column2, column3,…)
VALUES
(value1, value2, value3 …);

INSERT INTO Employee (
   EmployeeNo,
   FirstName,
   LastName,
   BirthDate,
   JoinedDate,
   DepartmentNo
)
VALUES (
   101,
   'Mike',
   'James',
   '1980-01-05',
   '2005-03-27',
   01
);

INSERT INTO <tablename>
(column1, column2, column3,…)
SELECT
column1, column2, column3…
FROM
<source table>;

INSERT INTO Employee_Bkup (
   EmployeeNo,
   FirstName,
   LastName,
   BirthDate,
   JoinedDate,
   DepartmentNo
)
SELECT
   EmployeeNo,
   FirstName,
   LastName,
   BirthDate,
   JoinedDate,
   DepartmentNo
FROM
   Employee;

UPDATE <tablename>
SET <columnnamme> = <new value>
[WHERE condition];

UPDATE Employee
SET DepartmentNo = 03
WHERE EmployeeNo = 101;

SELECT Employeeno, DepartmentNo FROM Employee;
*** Query completed. One row found. 2 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo    DepartmentNo
-----------  -------------
   101             3

DELETE FROM  <tablename>
[WHERE condition];

DELETE FROM Employee
WHERE EmployeeNo = 101;

SELECT EmployeeNo FROM Employee;
*** Query completed. No rows found.
*** Total elapsed time was 1 second.

SELECT * FROM tablename
WHERE[condition];

SELECT * FROM Employee
WHERE EmployeeNo = 101;

 EmployeeNo          FirstName                      LastName
----------- ------------------------------ -----------------------------
   101                 Mike                           James

SELECT * FROM tablename
ORDER BY column 1, column 2..;

SELECT * FROM Employee
ORDER BY FirstName;

 EmployeeNo         FirstName                      LastName
----------- ------------------------------ -----------------------------
    104               Alex                           Stuart
    101               Mike                           James
    103               Peter                          Paul
    102               Robert                         Williams
    105               Robert                         James

SELECT column 1, column2 …. FROM tablename
GROUP BY column 1, column 2..;

SELECT DepartmentNo,Count(*) FROM
Employee
GROUP BY DepartmentNo;

 DepartmentNo    Count(*)
------------  -----------
     3             1
     1             1
     2             3

SELECT EmployeeNo, FirstName FROM
Employee
WHERE EmployeeNo BETWEEN 101 AND 103;

*** Query completed. 3 rows found. 2 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo            FirstName
-----------  ------------------------------
   101                   Mike
   102                   Robert
   103                   Peter

SELECT EmployeeNo, FirstName FROM
Employee
WHERE EmployeeNo in (101,102,103);

*** Query completed. 3 rows found. 2 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo            FirstName
-----------  ------------------------------
   101                   Mike
   102                   Robert
   103                   Peter

SELECT * FROM
Employee
WHERE EmployeeNo not in (101,102,103);

*** Query completed. 2 rows found. 6 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo          FirstName                      LastName
----------- ------------------------------ -----------------------------
    104                Alex                          Stuart
    105                Robert                        James

SELECT col1, col2, col3…
FROM
<table 1>
[WHERE condition]
UNION

SELECT col1, col2, col3…
FROM
<table 2>
[WHERE condition];

SELECT EmployeeNo
FROM
Employee
UNION

SELECT EmployeeNo
FROM
Salary;

EmployeeNo
-----------
   101
   102
   103
   104
   105

SELECT col1, col2, col3…
FROM
<table 1>
[WHERE condition]
UNION ALL

SELECT col1, col2, col3…
FROM
<table 2>
[WHERE condition];

SELECT EmployeeNo
FROM
Employee
UNION ALL

SELECT EmployeeNo
FROM
Salary;

 EmployeeNo
-----------
    101
    104
    102
    105
    103
    101
    104
    102
    103

SELECT col1, col2, col3…
FROM
<table 1>
[WHERE condition]
INTERSECT

SELECT col1, col2, col3…
FROM
<table 2>
[WHERE condition];

SELECT EmployeeNo
FROM
Employee
INTERSECT

SELECT EmployeeNo
FROM
Salary;

EmployeeNo
-----------
   101
   104
   102
   103

SELECT col1, col2, col3…
FROM
<table 1>
[WHERE condition]
MINUS

SELECT col1, col2, col3…
FROM
<table 2>
[WHERE condition];

SELECT EmployeeNo
FROM
Employee
MINUS

SELECT EmployeeNo
FROM
Salary;

EmployeeNo
-----------
   105

SELECT EXTRACT(YEAR FROM CURRENT_DATE);
EXTRACT(YEAR FROM Date)
-----------------------
        2016
SELECT EXTRACT(MONTH FROM CURRENT_DATE);
EXTRACT(MONTH FROM Date)
------------------------
          1
SELECT EXTRACT(DAY FROM CURRENT_DATE);
EXTRACT(DAY FROM Date)
------------------------
          1

SELECT EXTRACT(HOUR FROM CURRENT_TIMESTAMP);
EXTRACT(HOUR FROM Current TimeStamp(6))
---------------------------------------
                 4
SELECT EXTRACT(MINUTE FROM CURRENT_TIMESTAMP);
EXTRACT(MINUTE FROM Current TimeStamp(6))
-----------------------------------------
                 54
SELECT EXTRACT(SECOND FROM CURRENT_TIMESTAMP);
EXTRACT(SECOND FROM Current TimeStamp(6))
-----------------------------------------
              27.140000

SELECT CURRENT_DATE, CURRENT_DATE + INTERVAL '03' YEAR;
  Date    (Date+ 3)
--------  ---------
16/01/01   19/01/01

SELECT CURRENT_DATE, CURRENT_DATE + INTERVAL '03-01' YEAR TO MONTH;
 Date     (Date+ 3-01)
--------  ------------
16/01/01    19/02/01

SELECT CURRENT_TIMESTAMP,CURRENT_TIMESTAMP + INTERVAL '01 05:10' DAY TO MINUTE;
     Current TimeStamp(6)         (Current TimeStamp(6)+ 1 05:10)
--------------------------------  --------------------------------
2016-01-01 04:57:26.360000+00:00  2016-01-02 10:07:26.360000+00:00

CASE <expression>
WHEN <expression> THEN result-1
WHEN <expression> THEN result-2

ELSE
   Result-n
END

SELECT
   EmployeeNo,
CASE DepartmentNo
   WHEN 1 THEN 'Admin'
   WHEN 2 THEN 'IT'
ELSE 'Invalid Dept'
   END AS Department
FROM Employee;

*** Query completed. 5 rows found. 2 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo    Department
-----------   ------------
   101         Admin
   104         IT
   102         IT
   105         Invalid Dept
   103         IT

SELECT
   EmployeeNo,
CASE
   WHEN DepartmentNo = 1 THEN 'Admin'
   WHEN  DepartmentNo = 2 THEN 'IT'
ELSE 'Invalid Dept'
   END AS Department
FROM Employee;

COALESCE(expression 1, expression 2, ....)

SELECT
   EmployeeNo,
   COALESCE(dept_no, 'Department not found')
FROM
   employee;

NULLIF(expression 1, expression 2)

SELECT
   EmployeeNo,
   NULLIF(DepartmentNo,3) AS department
FROM Employee;

*** Query completed. 5 rows found. 2 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo      department
-----------  ------------------
    101              1
    104              2
    102              2
    105              ?
    103              2

CREATE SET TABLE Salary (
   EmployeeNo INTEGER,
   Gross INTEGER,
   Deduction INTEGER,
   NetPay INTEGER
)
UNIQUE PRIMARY INDEX(EmployeeNo);

CREATE SET TABLE Employee _Accounts (
   EmployeeNo INTEGER,
   employee_bank_account_type BYTEINT.
   employee_bank_account_number INTEGER,
   employee_bank_name VARCHAR(30),
   employee_bank_city VARCHAR(30)
)
PRIMARY INDEX(EmployeeNo);

SELECT col1, col2, col3….
FROM
Table-1
INNER JOIN
Table-2
ON (col1 = col2)
<WHERE condition>;

SELECT A.EmployeeNo, A.DepartmentNo, B.NetPay
FROM
Employee A
INNER JOIN
Salary B
ON (A.EmployeeNo = B. EmployeeNo);

*** Query completed. 4 rows found. 3 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo   DepartmentNo     NetPay
-----------  ------------   -----------
    101           1            36000
    102           2            74000
    103           2            83000
    104           2            70000

SELECT col1, col2, col3….
FROM
Table-1
LEFT OUTER JOIN/RIGHT OUTER JOIN/FULL OUTER JOIN
Table-2
ON (col1 = col2)
<WHERE condition>;

SELECT A.EmployeeNo, A.DepartmentNo, B.NetPay
FROM
Employee A
LEFT OUTER JOIN
Salary B
ON (A.EmployeeNo = B. EmployeeNo)
ORDER BY A.EmployeeNo;

*** Query completed. 5 rows found. 3 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo  DepartmentNo     NetPay
-----------  ------------   -----------
    101           1           36000
    102           2           74000
    103           2           83000
    104           2           70000
    105           3             ?

SELECT A.EmployeeNo, A.DepartmentNo, B.EmployeeNo,B.NetPay
FROM
Employee A
CROSS JOIN
Salary B
WHERE A.EmployeeNo = 101
ORDER BY B.EmployeeNo;

*** Query completed. 4 rows found. 4 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo  DepartmentNo   EmployeeNo    NetPay
-----------  ------------  -----------  -----------
    101           1            101         36000
    101           1            104         70000
    101           1            102         74000
    101           1            103         83000

SELECT
Emp.EmployeeNo,
Emp.FirstName,
Empsal.NetPay
FROM
Employee Emp,
(select EmployeeNo , NetPay
from Salary
where NetPay >= 75000) Empsal
where Emp.EmployeeNo = Empsal.EmployeeNo;

*** Query completed. One row found. 3 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo            FirstName               NetPay
-----------  ------------------------------  -----------
    103                  Peter                 83000

CREATE [SET|MULTISET] VOALTILE TABLE tablename
<table definitions>
<column definitions>
<index definitions>
ON COMMIT [DELETE|PRESERVE] ROWS

CREATE VOLATILE TABLE dept_stat (
   dept_no INTEGER,
   avg_salary INTEGER,
   max_salary INTEGER,
   min_salary INTEGER
)
PRIMARY INDEX(dept_no)
ON COMMIT PRESERVE ROWS;

*** Table has been created.
*** Total elapsed time was 1 second.

CREATE [SET|MULTISET] GLOBAL TEMPORARY TABLE tablename
<table definitions>
<column definitions>
<index definitions>

CREATE SET GLOBAL TEMPORARY TABLE dept_stat (
   dept_no INTEGER,
   avg_salary INTEGER,
   max_salary INTEGER,
   min_salary INTEGER
)
PRIMARY INDEX(dept_no);

*** Table has been created.
*** Total elapsed time was 1 second.

CREATE UNIQUE INDEX(EmployeeNo) on employee;

CREATE INDEX(FirstName) on Employee;

COLLECT [SUMMARY] STATISTICS
INDEX (indexname) COLUMN (columnname)
ON <tablename>;

COLLECT STATISTICS COLUMN(EmployeeNo) ON Employee;

*** Update completed. 2 rows changed.
*** Total elapsed time was 1 second.

HELP STATISTICS <tablename>;

HELP STATISTICS employee;

  Date       Time      Unique Values           Column Names
--------   -------- -------------------- -----------------------
16/01/01   08:07:04         5                       *
16/01/01   07:24:16         3                   DepartmentNo
16/01/01   08:07:04         5                   EmployeeNo

EXPLAIN SELECT * FROM employee;

1) First, we lock a distinct TDUSER."pseudo table" for read on a
   RowHash to prevent global deadlock for TDUSER.employee.
2) Next, we lock TDUSER.employee for read.
3) We do an all-AMPs RETRIEVE step from TDUSER.employee by way of an
   all-rows scan with no residual conditions into Spool 1
   (group_amps), which is built locally on the AMPs.  The size of
   Spool 1 is estimated with low confidence to be 2 rows (116 bytes).
   The estimated time for this step is 0.03 seconds.
4) Finally, we send out an END TRANSACTION step to all AMPs involved
   in processing the request.
→ The contents of Spool 1 are sent back to the user as the result of
   statement 1.  The total estimated time is 0.03 seconds.

CREATE SET TABLE SALARY,FALLBACK (
   EmployeeNo INTEGER,
   Gross INTEGER,
   Deduction INTEGER,
   NetPay INTEGER
)
PRIMARY INDEX ( EmployeeNo )
UNIQUE INDEX (EmployeeNo);

EXPLAIN SELECT * FROM Salary WHERE EmployeeNo = 101;

1) First, we do a two-AMP RETRIEVE step from TDUSER.Salary
   by way of unique index # 4 "TDUSER.Salary.EmployeeNo =
   101" with no residual conditions.  The estimated time for this
   step is 0.01 seconds.
→ The row is sent directly back to the user as the result of
   statement 1.  The total estimated time is 0.01 seconds.

CREATE JOIN INDEX <index name>
AS
<SELECT Query>
<Index Definition>;

CREATE SET TABLE EMPLOYEE,FALLBACK (
   EmployeeNo INTEGER,
   FirstName VARCHAR(30) ,
   LastName VARCHAR(30) ,
   DOB DATE FORMAT 'YYYY-MM-DD',
   JoinedDate DATE FORMAT 'YYYY-MM-DD',
   DepartmentNo BYTEINT
)
UNIQUE PRIMARY INDEX ( EmployeeNo );

CREATE SET TABLE SALARY,FALLBACK (
   EmployeeNo INTEGER,
   Gross INTEGER,
   Deduction INTEGER,
   NetPay INTEGER
)
PRIMARY INDEX ( EmployeeNo )
UNIQUE INDEX (EmployeeNo);

CREATE JOIN INDEX Employee_JI
AS
SELECT EmployeeNo,FirstName,LastName,
BirthDate,JoinedDate,DepartmentNo
FROM Employee
PRIMARY INDEX(FirstName);

EXPLAIN SELECT * FROM EMPLOYEE WHERE FirstName='Mike';
*** Help information returned. 8 rows.
*** Total elapsed time was 1 second.
Explanation
------------------------------------------------------------------------
   1) First, we do a single-AMP RETRIEVE step from EMPLOYEE_JI by
      way of the primary index "EMPLOYEE_JI.FirstName = 'Mike'"
      with no residual conditions into Spool 1 (one-amp), which is built
      locally on that AMP.  The size of Spool 1 is estimated with low
      confidence to be 2 rows (232 bytes).  The estimated time for this
      step is 0.02 seconds.
   → The contents of Spool 1 are sent back to the user as the result of
      statement 1.  The total estimated time is 0.02 seconds.

CREATE JOIN INDEX Employee_Salary_JI
AS
SELECT a.EmployeeNo,a.FirstName,a.LastName,
a.BirthDate,a.JoinedDate,a.DepartmentNo,b.Gross,b.Deduction,b.NetPay
FROM Employee a
INNER JOIN Salary b
ON(a.EmployeeNo = b.EmployeeNo)
PRIMARY INDEX(FirstName);

CREATE JOIN INDEX Employee_Salary_JI
AS
SELECT a.DepartmentNo,SUM(b.NetPay) AS TotalPay
FROM Employee a
INNER JOIN Salary b
ON(a.EmployeeNo = b.EmployeeNo)
GROUP BY a.DepartmentNo
Primary Index(DepartmentNo);

CREATE/REPLACE VIEW <viewname>
AS
<select query>;

CREATE VIEW Employee_View
AS
SELECT
EmployeeNo,
FirstName,
LastName,
FROM
Employee;

SELECT EmployeeNo, FirstName, LastName FROM Employee_View;

*** Query completed. 5 rows found. 3 columns returned.
*** Total elapsed time was 1 second.
 EmployeeNo            FirstName                       LastName
-----------  ------------------------------  ---------------------------
    101                  Mike                           James
    104                  Alex                           Stuart
    102                  Robert                         Williams
    105                  Robert                         James
    103                  Peter                          Paul

REPLACE VIEW Employee_View
AS
SELECT
EmployeeNo,
FirstName,
BirthDate,
JoinedDate
DepartmentNo
FROM
Employee;

DROP VIEW <viewname>;

DROP VIEW Employee_View;

CREATE MACRO <macroname> [(parameter1, parameter2,...)] (
   <sql statements>
);

CREATE MACRO Get_Emp AS (
   SELECT
   EmployeeNo,
   FirstName,
   LastName
   FROM
   employee
   ORDER BY EmployeeNo;
);

EXEC <macroname>;

EXEC Get_Emp;
*** Query completed. 5 rows found. 3 columns returned.
*** Total elapsed time was 1 second.
EmployeeNo             FirstName                      LastName
-----------  ------------------------------  ---------------------------
   101                  Mike                          James
   102                  Robert                        Williams
   103                  Peter                         Paul
   104                  Alex                          Stuart
   105                  Robert                        James

EXEC <macroname>(value);

EXEC Get_Emp_Salary(101);
*** Query completed. One row found. 2 columns returned.
*** Total elapsed time was 1 second.

EmployeeNo      NetPay
-----------  ------------
   101           36000

CREATE PROCEDURE <procedurename> ( [parameter 1 data type, parameter 2 data type..] )
BEGIN
   <SQL or SPL statements>;
END;

CREATE PROCEDURE InsertSalary (
   IN in_EmployeeNo INTEGER, IN in_Gross INTEGER,
   IN in_Deduction INTEGER, IN in_NetPay INTEGER
)
BEGIN
   INSERT INTO Salary (
      EmployeeNo,
      Gross,
      Deduction,
      NetPay
   )
   VALUES (
      :in_EmployeeNo,
      :in_Gross,
      :in_Deduction,
      :in_NetPay
   );
END;

CALL <procedure name> [(parameter values)];

CALL InsertSalary(105,20000,2000,18000);

CREATE SET TABLE EMPLOYEE,FALLBACK (
   EmployeeNo INTEGER,
   FirstName VARCHAR(30) ,
   LastName VARCHAR(30) ,
   DOB DATE FORMAT 'YYYY-MM-DD',
   JoinedDate DATE FORMAT 'YYYY-MM-DD',
   DepartmentNo BYTEINT
)
UNIQUE PRIMARY INDEX ( EmployeeNo );

CREATE SET TABLE Salary (
   EmployeeNo INTEGER,
   Gross INTEGER,
   Deduction INTEGER,
   NetPay INTEGER
)
UNIQUE PRIMARY INDEX(EmployeeNo);

CREATE SET TABLE EMPLOYEE,FALLBACK (
   EmployeeNo INTEGER,
   FirstName VARCHAR(30) ,
   LastName VARCHAR(30) ,
   DOB DATE FORMAT 'YYYY-MM-DD',
   JoinedDate DATE FORMAT 'YYYY-MM-DD',
   DepartmentNo BYTEINT
)
UNIQUE PRIMARY INDEX ( EmployeeNo );

CREATE SET TABLE DEPARTMENT,FALLBACK (
   DepartmentNo BYTEINT,
   DepartmentName CHAR(15)
)
UNIQUE PRIMARY INDEX ( DepartmentNo );

RANK() OVER
([PARTITION BY columnnlist] [ORDER BY columnlist][DESC|ASC])

SELECT EmployeeNo, JoinedDate,RANK()
OVER(ORDER BY JoinedDate) as Seniority
FROM Employee;

EmployeeNo   JoinedDate   Seniority
-----------  ----------  -----------
   101       2005-03-27       1
   103       2007-03-21       2
   102       2007-04-25       3
   105       2008-01-04       4
   104       2008-02-01       5

SELECT EmployeeNo, JoinedDate,RANK()
OVER(PARTITION BY DeparmentNo ORDER BY JoinedDate) as Seniority
FROM Employee;

EmployeeNo  DepartmentNo  JoinedDate   Seniority
-----------  ------------  ----------  -----------

    101           1        2005-03-27       1
    103           2        2007-03-21       1
    102           2        2007-04-25       2
    104           2        2008-02-01       3
    105           3        2008-01-04       1

CREATE USER username
AS
[PERMANENT|PERM] = n BYTES
PASSWORD = password
TEMPORARY = n BYTES
SPOOL = n BYTES;

CREATE USER TD01
AS
PERMANENT = 1000000 BYTES
PASSWORD = ABC$124
TEMPORARY = 1000000 BYTES
SPOOL = 1000000 BYTES;

CREATE USER username
PERM = n BYTES
PASSWORD = password
ACCOUNT = accountid

CREATE USER TD02
AS
PERMANENT = 1000000 BYTES
PASSWORD = abc$123
TEMPORARY = 1000000 BYTES
SPOOL = 1000000 BYTES
ACCOUNT = (‘IT’,’Admin’);

.LOGON username, passowrd,accountid
OR
SET SESSION ACCOUNT = accountid

GRANT privileges ON objectname TO username;

GRANT SELECT,INSERT,UPDATE ON Employee TO TD01;

REVOKE [ALL|privileges] ON objectname FROM username;

REVOKE INSERT,SELECT ON Employee FROM TD01;

101,Mike,James,1980-01-05,2010-03-01,1
102,Robert,Williams,1983-03-05,2010-09-01,1
103,Peter,Paul,1983-04-01,2009-02-12,2
104,Alex,Stuart,1984-11-06,2014-01-01,2
105,Robert,James,1984-12-01,2015-03-09,3

LOGON 192.168.1.102/dbc,dbc;
   DATABASE tduser;
   BEGIN LOADING tduser.Employee_Stg
      ERRORFILES Employee_ET, Employee_UV
      CHECKPOINT 10;
      SET RECORD VARTEXT ",";
      DEFINE in_EmployeeNo (VARCHAR(10)),
         in_FirstName (VARCHAR(30)),
         in_LastName (VARCHAR(30)),
         in_BirthDate (VARCHAR(10)),
         in_JoinedDate (VARCHAR(10)),
         in_DepartmentNo (VARCHAR(02)),
         FILE = employee.txt;
      INSERT INTO Employee_Stg (
         EmployeeNo,
         FirstName,
         LastName,
         BirthDate,
         JoinedDate,
         DepartmentNo
      )
      VALUES (
         :in_EmployeeNo,
         :in_FirstName,
         :in_LastName,
         :in_BirthDate (FORMAT 'YYYY-MM-DD'),
         :in_JoinedDate (FORMAT 'YYYY-MM-DD'),
         :in_DepartmentNo
      );
   END LOADING;
LOGOFF;

101,Mike,James,1980-01-05,2010-03-01,1
102,Robert,Williams,1983-03-05,2010-09-01,1
103,Peter,Paul,1983-04-01,2009-02-12,2
104,Alex,Stuart,1984-11-06,2014-01-01,2
105,Robert,James,1984-12-01,2015-03-09,3

.LOGTABLE tduser.Employee_log;
.LOGON 192.168.1.102/dbc,dbc;
   .BEGIN MLOAD TABLES Employee_Stg;
      .LAYOUT Employee;
      .FIELD in_EmployeeNo * VARCHAR(10);
      .FIELD in_FirstName * VARCHAR(30);
      .FIELD in_LastName * VARCHAR(30);
      .FIELD in_BirthDate * VARCHAR(10);
      .FIELD in_JoinedDate * VARCHAR(10);
      .FIELD in_DepartmentNo * VARCHAR(02);

      .DML LABEL EmpLabel;
      INSERT INTO Employee_Stg (
         EmployeeNo,
         FirstName,
         LastName,
         BirthDate,
         JoinedDate,
         DepartmentNo
      )
      VALUES (
         :in_EmployeeNo,
         :in_FirstName,
         :in_Lastname,
         :in_BirthDate,
         :in_JoinedDate,
         :in_DepartmentNo
      );
      .IMPORT INFILE employee.txt
      FORMAT VARTEXT ','
      LAYOUT Employee
      APPLY EmpLabel;
   .END MLOAD;
LOGOFF;

.LOGON 192.168.1.102/dbc,dbc;
   DATABASE tduser;

   CREATE TABLE employee_bkup (
      EmployeeNo INTEGER,
      FirstName CHAR(30),
      LastName CHAR(30),
      DepartmentNo SMALLINT,
      NetPay INTEGER
   )
   Unique Primary Index(EmployeeNo);

   .IF ERRORCODE <> 0 THEN .EXIT ERRORCODE;

   SELECT * FROM
   Employee
   Sample 1;
   .IF ACTIVITYCOUNT <> 0 THEN .GOTO InsertEmployee;

   DROP TABLE employee_bkup;

   .IF ERRORCODE <> 0 THEN .EXIT ERRORCODE;

   .LABEL InsertEmployee
   INSERT INTO employee_bkup
   SELECT a.EmployeeNo,
      a.FirstName,
      a.LastName,
      a.DepartmentNo,
      b.NetPay
   FROM
   Employee a INNER JOIN Salary b
   ON (a.EmployeeNo = b.EmployeeNo);

   .IF ERRORCODE <> 0 THEN .EXIT ERRORCODE;
.LOGOFF;