【实习之T100开发】Genero FGL (TIPTOP4GL) 学习笔记（2）

【实习】T100学习笔记

CURSOR

在 Genero FGL 语言中，当下达 DATABASE dstabase_id 指令后，即与数据库执行链接，也就是可以开始进行数据的 查询（SELECT）、更改（UPDATE）、新增（INSERT）等 动作。

在处理数据时若只有 单笔数据 的选取，则可用 单纯的 SQL 指令即可。

若是要抓取 多笔数据 处理时，就会因抓取的特性不同（例如：一次只抓一笔数据处理，完成后再抓次笔，如『个人资料表』；或一次全部抓取，一起编辑，如『个人门禁进出记录表』等），而需使用不同的 指标（CURSOR）。

CONSTRUCT：获取用户输入组成【WHERE条件】

作用：让用户在画面上输入查询条件（通称 Query By Example；QBE），以取得用户的查询范围数据。

用户的查询数据会组成一串 【WHERE 条件】，并置入设定好的变量中。若使用者未输入任何条件，即按下『确定』离开 CONSTRUCT，系统也会自动于此变量中补入 1=1。

• 当 域名column_list 与 变量名field_list 相同时，可以采用语法2
• char_variable 为接取用户输入数据的 字符串变量（建议以 STRING 格式变量接取）
• column_list 为对应到表格（TABLE）的域名清单（逗号隔开）
• field_list 为画面（WINDOW 或是 FORM）上的字段代码清单（逗号隔开）
• 若有增加 控制区段 (如ON ACTION等)，则就要加上END CONSTRUCT

语法1示例：

CONSTRUCT BY NAME l_str ON employee, salary
	ON IDLE 10
	EXIT PROGRAM
END CONSTRUCT

经过上图用户输入的条件，在程序中进行了拼接，形成一个【WHERE 条件】：

l_str = "employee='1000" AND salary>30000"

后续在组 SQL 指令时，即可通过此变量组出符合条件的 SQL 查询指令。

PREPARE：将【SQL字符串】转成【可执行SQL】

若已经得到一个完整的【WHERE 条件】后，接下来即可将此条件，组合成 SQL 字符串，再转换为一个完整且可以抓取符合条件的 SQL 指令。

执行完 CONSTRUCT 后，系统只能得到一个 SQL 字符串，并非为『可执行的指令』，因此必须通过 PREPARE 指令，将此 SQL 字符串转换成『可执行的 SQL 指令』。

PREPARE 会将字符串传入数据库查核语法的正确性，再回传一个 prepared-id 后续调用。

• statement-name 是一个 PREPARE 完成后的 可执行SQL（prepared-id）
• 执行 PREPARE 指令前必须先拼接好 SELECT 语句。

LET l_sql = "SELECT * FROM employee_file",
			"WHERE", l_str # l_str 是经过 CONSTRUCT 得到的【WHERE条件】
PREPARE emp_pre FROM l_sql

FREE：释放 PREPARE 的记录

FREE 用于 释放 PREPARE 的记录。
语法：FREE statement-name

LET l_str = " employee='1000' AND salary>'30000' "
LET l_sql = " SELECT * FROM employee_file WHERE ", l_str
PREPARE emp_pre FROM l_sql
...
FREE emp_pre

数据的查询

Genero FGL 中有两种查询用的指标（CURSOR）可以运用在资料的查询

1. SCROLLING CURSOR
2. Non-SCROLLING CURSOR

SCROLLING CURSOR 通常运用在 单文件控制 或 查询类 的程序，如『个人资料表』般的作业，可以随机抓取数据，一次一笔，再处理完后可以选择 往前一比、往后一笔 或 往这个查询序列中的任何一笔数据 移动的指针（CURSOR）。

DECLARE cursor_id SCROLL CURSOR [WITH HOLD] FOR sql statement
OPEN cursor_id [USING value]
FETCH [first|last|previous|next| cursor_id INTO variable
CLOSE cursor_id

Non-SCROLLING CURSOR 通常运用在 双文件控制程序 或 报表 程序，如『个人出缺勤统计表』般的作业，抓取数据是 依序 (seguential) 的方式，一次可以将合条件要求的资料一笔接着一笔的抓出，直到资料全数抓完（或被强制终止）为止。

DECLARE cursor_id CURSOR [WITH HOLD] FOR sql statement
FOREACH cursor_id
[USING value]
[INTO variable ]
	...
END FOREACH

SCROLLING CURSOR（DECLARE、OPEN、FETCH、CLOSE）

说明：通常用于 查询程序，可以 随即抓取资料。

1. 通过 DECLARE 定义
2. 利用 OPEN 开启该 CURSOR
   例：OPEN test01_cursor
3. 通过 FETCH cursor_name INTO 变量 抓取资料

DECLARE 概述
语法1：使用 已知的SQL语句 进行 CURSOR 声明

DECLARE cursor_name SCROLL CURSOR [WITH HOLD] 
	FOR sql_statement

语法2：使用 已声明的PREPARED ID 来进行 CURSOR 声明

DECLARE cursor_name SCROLL CURSOR [WITH HOLD] 
	FOR prepared_id

语法3：使用 已知的STRING语句 进行 CURSOR 声明

DECLARE cursor_name SCROLL CURSOR [WITH HOLD] 
	FROM string-expression

OPEN 概述
语法：

OPEN cursor_name [USING 变量名称]

• 本指令可用 STATUS 来检查是否执行成功
• 使用 cursor 之前要先 OPEN CURSOR，开启游标
• 此语句仅决定符合的数据，并不是真正从数据库中抓取数据

示例：

LET g_sql = "SELECT * FROM cta_file WHERE ROWID = ?" 

DECLARE cta_cl CURSOR FROM g_sql 
			:
OPEN cta_cl USING l_ata01

FETCH 概述
语法：

FETCH cursor_id INTO program_variable

当声明为 SCROLLING CURSOR 时，可以配合以下移动 Cursor 的指令：

不同 FETCH 指令下 CURSOR 动作示意图：

LET l_sql = "SELECT * FROM employee_file", "WHERE", l_str

PREPARE emp_pre FROM l_sql 

DECLARE emp_cus SCROLL CURSOR 
[WITH HOLD] FOR emp_pre 

OPEN emp_cus # OPEN CURSOR

FETCH FIRST emp_cus INTO l_emp.*  #抓第一笔

CLOSE 概述
语法：

CLOSE cursor_id

说明：关闭并释放指标（CURSOR）的储存空间

---

综合示例

DATABASE ds #声明数据库

MAIN
	DEFINE a STRING
	DEFINE b,c CHAR(10)
	
	# 使用 SQL语句 声明 CURSOR
	DECLARE test01 SCROLL CURSOR FOR 
			SELECT zz01 FROM zz_file WHERE zz01 = "axmt410"
	OPEN test01
	FETCH FIRST test01 INTO b #将cursor指向符合条件的第一笔
	DISPLAY b
	
	LET c = "axmt410"
	LET a = "SELECT zz01 FROM zz_file WHERE zz01='",c CLIPPED,"' "
	# 使用 STRING语句 声明 CURSOR
	DECLARE test02 SCROLL CURSOR FROM a
	OPEN test02
	FETCH LAST test02 INTO b #将cursor指向符合条件的最后一笔
	DISPLAY b

END MAIN

Non-SCROLLING CURSOR（DECLARE、FOREACH）

说明：常运用在 报表程式，抓取资料的方式是 依序 (seguential) 的方式。

1. 通过 DECLARE 定义
2. 利用 FOREACH 指令抓资料

DECLARE 概述
语法1：使用 已知的SQL语句 进行 CURSOR 声明

DECLARE cursor_name CURSOR [WITH HOLD] 
	FOR sql_statement

语法2：使用 已声明的 PREPARED_ID 来进行 CURSOR 声明

DECLARE cursor_name CURSOR [WITH HOLD] 
	FOR prepared_id 

语法3：使用 已知的STRING语句 进行 CURSOR 声明

DECLARE cursor_name CURSOR [WITH HOLD] 
	FROM string-expression

FOREACH (LOOP) 概述
注：只能用于 Non_Scrolling Cursor

声明完 CURSOR 后即可用 FOREACH 进行将所有符合条件的数据一笔一笔的抓取出来处理，不需要 OPEN。

FOREACH 与 FETCH 的不同

• FOREACH 具有循环处理的架构，而 FETCH 则必须配合 WHILE 循环一起用。
• FOREACH 只能循序处理，而 FETCH 可做随机跳跃的选取。
• 执行 FETCH 前必须 OPEN，结束时 CLOSE 关闭并释放CURSOR
  FOREACH 指令可自动开启与关闭 CURSOR，无需手动 OPEN 和 CLOSE。

综合示例

LET l_sql = "SELECT * FROM employee_file", "WHERE", l_str 
PREPARE emp_pre FROM l_sql 
DECLARE emp_cus CURSOR FOR emp_pre # 使用 prepare_id 来声明 cursor
FOREACH emp_cus INTO l_emp.* #循序抓资料 
	IF l_emp.salary > 80000 THEN 
		EXIT FOREACH 
	END IF 
END FOREACH

MAIN
	DEFINE clist ARRAY[200] OF RECORD
			cnum INTEGER,
			cname CHAR(50)
		END RECORD
	
	DEFINE I INTEGER
	DEFINE str STRING
	DEFINE c_name CHAR(50)
	
	DATABASE stores
	
	LET c_name = ARG_VAL(1)
	
	LET str = "SELECT customer_num, cust_name FROM customer WHERE cname = ?"
	PREPARE prepare_id FROM str
	DECLARE c1 CURSOR FOR prepare_id # 使用 prepare_id 来声明 cursor
	LET i = 1
	FOREACH c1 USING c_name INTO clist[i].*
		LET i = i + 1
	END FOREACH
	
	DISPLAY "Number of rows found: ", i
END MAIN

数据的锁定

LOCKING CURSOR（DECLARE、OPEN、FETCH、CLOSE）

当要进行数据的修改 (UPDATE) 时，为防止多人同时修到同一笔数据，应当考虑在开始修改前进行 数据锁定（LOCK），以确保同时间只有一人能取得修改权，Genero FGL 中延续 INFORMIX 4GL 的作法，采用 LOCKING CURSOR 对数据进行锁定。

LOCKING CURSOR 也称 FOR UPDATE CURSOR。用于在数据更新程序段，将数据进行一个上锁的动作，以避免两组以上的联机同时再更新同一 TABLE 下的同一笔数据。如果未作 LOCK 的动作，可能再抓取数据的同时，有其他人正在进行数据修改。此 CURSOR 不属于数据查询的 CURSOR，而需列为更新的 CURSOR。

DECLARE cursor_name CURSOR FOR sql statement FOR UPDATE [NOWAIT]
OPEN cursor_id [USING value]
FETCH cursor_id INTO variable
CLOSE cursor_id

说明：通常运用在 Update程序，做资料Lock的动作。

1. 通过 DECLARE 定义
2. 通过 OPEN 开启该CURSOR
3. 通过 FETCH cursor_name INTO 变量 抓取资料

DECLARE 概述

DECLARE cursor_name CURSOR FOR select_statement FOR UPDATE [NOWAIT]

• 此处与 SCROLL CURSOR 或 Non-SCROLL CURSOR 最大的差异在于 SQL 查询指令的
  最后须加上FOR UPDATE(ORACLE 数据库需再加上 NOWAIT)，以标明此 CURSOR 为 LOCKING CURSOR。
• 此处亦可使用 FROM char_variable 方式来定义 SQL 查询指令。

OPEN 概述

OPEN cursor_id

FETCH 概述

FETCH cursor_id INTO program_variable

• 此指令除从数据库中取得数据外，在 LOCKING CURSOR 的状态下，还会将所抓取到的数据锁住，直到程序执行 CLOSE cursor_id 的指令才会释放。

CLOSE 概述

CLOSE cursor_id

• 关闭并释放 CURSOR，待释放完成后，系统才会将被锁定的数据释放。

综合案例

LET l_sql = "SELECT * FROM employee_file", 
			"WHERE no = ? FOR UPDATE" 
PREPARE emp_pre FROM l_sql 
DECLARE emp_cl CURSOR FOR emp_pre 
OPEN emp_cus USING l_no 
FETCH emp_cus INTO l_emp.*  #只抓一笔资料lock

DATABASE ds

MAIN
	 DEFINE g_gav01 LIKE gav_file.gav01
	 DEFINE g_gav08 LIKE gav_file.gav08
	 
	 LET g_forupd_sql = "SELECT * from gav_file WHERE gav01=? AND gav08=? ",
	 					"FOR UPDATE"
	 DECLARE p_per_lock_u CURSOR FROM g_forupd_sql
	 OPEN p_per_lock_u USING g_gav01,g_gav08
	 IF STATUS THEN
		 CLOSE p_per_lock_u
		 RETURN
	 END IF
	 FETCH p_per_lock_u INTO g_gav_lock.*
	 IF SQLCA.sqlcode THEN
		 CLOSE p_per_lock_u
		 RETURN
	 END IF
	 CLOSE p_per_lock_u
END MAIN

USING的使用时机

此处的『USING』和之前关于 变量格式输出的 USING 意义不同。

在组成查询的 SQL 指令时，有时一开始不知道要查询的数据是什么 ，因此『可在 SQL 查询指令中使用问号 ?，后续要使用 CURSOR 时，再将已知值用 USING 传入』。

说明

• SQL 语句中可以定义多个问号?；使用 USING 给值时需依序对应，并用逗号隔开
• USING 必需跟在 OPEN 后 (Scroll Cursor 及 Locking Cursor种)、FOREACH 后 (Nonscroll Cursor) 或 EXECUTE 指令后 (大量执行 SQL Cursor)

前面的案例中都用到了 USING。

TRANSACTION：事务控制

说明：需要多表格的同时连动时，可采用 TRANSACTION 作法。

1. 通过 BEGIN WORK 声明 TRANSACTION 开始
2. 执行 INSERT、UPDATE、DELETE 等指令
3. 通过 COMMIT WORK 或 ROLLBACK WORK 声明 TRANSACTION 结束

注意

• BEGIN WORK 开始后，一定要有 COMMIT WORK 或 ROLLBACK WORK
  也就是必须做出数据是否写入的判断
• TRANSACTION 区中的程序尽量不要太长，以免影响需要调用同笔数据的其他用户
  （但使用者本身不受影响，未 COMMIT WORK 前仍可调用已变更数据）
• 有些 DDL 指令 (如 CREATE TABLE) 会有自动 COMMIT WORK 功能
• 当 COMMIT WORK 或 ROLLBACK WORK 时，会自动关闭未声明『WITH HOLD』的 CURSOR

BEGIN WORK
...
[INSERT ...] 
[UPDATE ...] 
...
IF SQLCA.SQLCODE THEN #SQL执行结果
	ROLLBACK WORK 
ELSE 
	COMMIT WORK 
END IF

EXECUTE：大量执行同一SQL指令

当系统要执行大量的同一 SQL 指令，例如要在工作数据中连续 INSERT 十年的工作日数据，可以用 FOR 循环实现以下语句，但数据量大时效率会比较低。

INSERT INTO work_date VALUES ("2005/07/01", "Friday", "Weekday")

若对程序有效率要求，则可以考虑改用『EXECUTE』作法。

说明：需要大量执行同一SQL指令。

• EXECUTE 可以应用在 SELECT、UPDATE、INSERT、DELETE 等处
• 使用 EXECUTE 时，尽量将以 USING 方式传值

FUNCTION update_customer_name( key, name )
	DEFINE key INTEGER
	DEFINE name CHAR(10)
	PREPARE s1 FROM "UPDATE customer SET name=? WHERE customer_num=?"
	EXECUTE s1 USING name, key
	FREE s1
END FUNCTION

PUT…FLUSH：大量执行新增指令

若是需要大量 INSERT 操作，『INSERT CURSOR』比 EXECUTE 更快。

示例：

MAIN
	DEFINE i INTEGER
	DEFINE rec RECORD
			key INTEGER,
			name CHAR(30)
		END RECORD
	
	DATABASE stock
	
	PREPARE is FROM "INSERT INTO item VALUES (?,?)"
	DECLARE ic CURSOR FOR is
	
	BEGIN WORK # 开启事务
		OPEN ic
		FOR i=1 TO 100
			LET rec.key = i
			LET rec.name = "Item #" || i
			PUT ic FROM rec.*
			IF i MOD 50 = 0 THEN
				FLUSH ic
			END IF
		END FOR
		CLOSE ic
	COMMIT WORK # 提交事务
	
	FREE ic
	FREE is
END MAIN

ARRAY

ARRAY的定义和方法

Genero 的数组可以设定为一维，二维或多维数组，其计数从『1』开始。若未知数组所需要的长度，可以宣告为动态数组。

固定数组（Static Array）定义

ARRAY [ intconst [,intconst [,intconst] ] ] OF datatype

动态数组（Dynamic Array）定义

DYNAMIC ARRAY [ WITH DIMENSION rank ] OF datatype

数组对象可用方法（Method）列表：

示例：定义固定及动态数组

MAIN
	DEFINE a1 ARRAY[100] OF INTEGER #定义容量为100的固定数组
	DEFINE a2 DYNAMIC ARRAY OF INTEGER #定义动态数组
	DEFINE i INTEGER
	LET i = 12
	LET a1[50] = 12456
	LET a2[5000] = 12456
	LET a2[500+i] = 12456
END MAIN

示例：getLength() 和 claer()

MAIN
	DEFINE a DYNAMIC ARRAY OF INTEGER
	LET a[5000] = 123456
	DISPLAY a.getLength() # 5000
	CALL a.clear() #清空数组
	DISPLAY a.getLength() # 0
END MAIN

示例：appendElement()

MAIN
	DEFINE a DYNAMIC ARRAY OF INTEGER
	LET a[10] = 10
	CALL a.appendElement()
	LET a[a.getLength()] = a.getLength()
	DISPLAY a.getLength() # 11
	DISPLAY a[10] # 10
	DISPLAY a[11] # 11
END MAIN

示例：insertElement(n) 在下标n处新增记录，并将n之后的数据后移

MAIN
	DEFINE a DYNAMIC ARRAY OF INTEGER
	LET a[10] = 11
	
	CALL a.insertElement(10) #a[10]新增记录,原本a[10]的数据后移
	LET a[10] = 10 #给新增的记录赋值
	
	DISPLAY a.getLength() # 11
	DISPLAY a[10] # 10
	DISPLAY a[11] # 11
END MAIN

范例5：deleteElement(n) 删除下标为n处的记录

MAIN
	DEFINE a DYNAMIC ARRAY OF INTEGER
	LET a[10] = 9
	DISPLAY a.getLength() # 10
	CALL a.deleteElement(5)
	DISPLAY a.getLength() # 9
	DISPLAY a[9] # 9
END MAIN

示例：二、三维数组？？？？？？？？？？？？？？

MAIN
	DEFINE a2 DYNAMIC ARRAY WITH DIMENSION 2 OF INTEGER
	DEFINE a3 DYNAMIC ARRAY WITH DIMENSION 3 OF INTEGER
	LET a2[50,100] = 12456
	LET a2[51,1000] = 12456
	DISPLAY a2.getLength()
	DISPLAY a2[50].getLength()
	DISPLAY a2[51].getLength()
	LET a3[50,100,100] = 12456
	LET a3[51,101,1000] = 12456
	DISPLAY a3.getLength()
	DISPLAY a3[50].getLength()
	DISPLAY a3[51].getLength()
	DISPLAY a3[50,100].getLength()
	DISPLAY a3[51,101].getLength()
	CALL a3[50].insertElement(10)
	CALL a3[50,10].insertElement(1)
END MAIN

---

程序中常见的静态数组定义：主要用于单头，搭配execute，fetch使用

DEFINE p_employee RECORD
	no		LIKE employee_t.no,
	name	LIKE employee_t.name
	tel		LIKE employee_t.tel,
	address	LIKE employee_t.address,
	salary 	LIKE employee_t.salary
END RECORD

INITIALIZE p_employee.* TO NULL # 静态数组的初始化

程序中常见的动态数组定义：主要用于单身或查询报表，搭配foreach使用

DEFINE p_employee DYNAMIC ARRAY OF RECORD
	no		LIKE employee_t.no,
	name	LIKE employee_t.name
	tel		LIKE employee_t.tel,
	address	LIKE employee_t.address,
	salary 	LIKE employee_t.salary
END RECORD

CALL p_employee.clear() # 动态数组的初始化

显示数组内容 DISPLAY ARRAY

语法：

DISPLAY ARRAY record-array TO screen-array.* 
	[ HELP help-number ] 
	[ATTRIBUTE ( [,...] )

示例：

# 将4gl里面的全局变量（动态数组）显示到屏幕变量上
DISPLAY ARRAY p_employee.* TO s_employee.*

数组内容输入 INPUT ARRAY

• BEFORE INPUT
  在进入input之前要做的需求设定
  例如将单身的栏位设置为不可录入

• AFTER INPUT

• BEFORE ROW
  在进入单身的某行之前，现有开启事务，判断当前是修改还是新增的状态，如果是修改的状态，需要将单身的资料锁住不让其他人修改

• AFTER ROW

• BEFORE FIELD field-list

• AFTER FIELD field-list

• ON ROW CHANGE
  当单身的某一行发生改变时，会update单身表的资料

• ON CHANGE field-list

• ON IDLE idle-seconds

• ON ACTION action-name

• BEFORE INSERT
  如果当前的状态是新增，这里是给单身的栏位做预设值，例如：项次自增，复选框默认为N…

• AFTER INSERT
  将在单身输入的值判断，是否已经存在单身表，如果不存在就新增一笔数据到表，如果已经存在就修改表的资料

• BEFORE DELETE
  在删除单身数据时要做的逻辑判断

• AFTER DELETE

• END INPUT

控制段执行顺序