Back to Contents

Arrays

Summary:

• Syntax
• Usage
• Examples

See also: Variables, Records, Data Types.

Syntax

Purpose:

Arrays can store a one-, two- or three-dimensional array of elements.

Syntax 1: Static array definition

Syntax 2: Dynamic array definition

Notes:

1. intconst can be an integer literal or an integer constant.
2. rank can be an integer literal of 1, 2, or 3. Default is 1. 
3. datatype can be any data type or a record definition.
4. A single array element can be referenced by specifying its coordinates in each dimension of the array.
5. Out of range coordinates raise error -1326.
6. The elements of an array variable can be of any data type except an array definition, but an element can be a record that contains an array member.

Methods:

Warnings:

1. All elements of static arrays are initialized; memory is allocated for all elements.
2. You cannot specify an array as an argument or as a returned value of a function.
3. In the DEFINE section of a REPORT statement, formal arguments cannot be declared as arrays, nor as record variables that contain array members.

Usage

Arrays can store a one-, two- or three-dimensional array of variables, all of the same type. These can be any of the supported data types or a record definition, but it cannot be another array (ARRAY .. OF ARRAY).

The first syntax (ARRAY[i[,j[,k]]]) defines traditional static arrays, which are defined with an explicit size for all dimensions. Static arrays have a size limit.

Warning: Because of backward compatibility with Informix 4gl, all elements of static arrays are initialized, even if the array is not used. Therefore, it is not recommended to define huge static arrays, as they can use a lot of memory.

The second syntax (DYNAMIC ARRAY) define arrays with a variable size. Dynamic arrays have no theoretical size limit. The elements of dynamic arrays are allocated automatically by the runtime system, according to the indexes used.

01 MAIN
02   DEFINE a1 ARRAY[100] OF INTEGER -- This is a static array
03   DEFINE a2 DYNAMIC ARRAY OF INTEGER -- This is a dynamic array
04   LET a1[50] = 12456
05   LET a2[5000] = 12456  -- Automatic allocation for element 5000
06   LET a1[5000] = 12456  -- Runtime error!
07 END MAIN

When using the array, you can specify the index with an integer expression:

01 MAIN
02   DEFINE a DYNAMIC ARRAY OF INTEGER
03   DEFINE i INTEGER
04   LET i = 12
05   LET a[500+i] = 12456
06 END MAIN

For dynamic arrays, memory is allocated dynamically. Large array indexes can be used without consuming a lot of memory resources.

01 SCHEMA stores
02 MAIN
03   DEFINE a DYNAMIC ARRAY OF RECORD LIKE customer.*
04   DEFINE i INTEGER
05   DATABASE stores
06   DECLARE c CURSOR FOR SELECT * FROM customer
07   LET i=0
08   FOREACH c INTO a[i+1].*
09     LET i=i+1
10   END FOREACH
11   CALL a.deleteElement(i+1)
12   DISPLAY "Rows found: ", a.getLength()
13 END MAIN

Warning: A dynamic array element is allocated before it is used. For example, in the above code, since the FOREACH instruction uses INTO a[i+1].*, an additional element is allocated during the last FETCH returning NOTFOUND. Therefore, the last element must be removed after the FOREACH loop.  

Here is the recommended way to fetch rows into a dynamic array:

01 SCHEMA stores
02 MAIN
03   DEFINE a DYNAMIC ARRAY OF RECORD LIKE customer.*
04   DEFINE r RECORD LIKE customer.*
05   DEFINE i INTEGER
06   DATABASE stores
07   DECLARE c CURSOR FOR SELECT * FROM customer
08   LET i=0
09   FOREACH c INTO r.*
10     LET i=i+1
11     LET a[i].* = r.*
12   END FOREACH
13   DISPLAY "Rows found: ", a.getLength()
14 END MAIN

If you reference an array element in an r-value, with an index outside the allocated dimensions, you get a -1326 runtime error: 

01 MAIN
02   DEFINE a DYNAMIC ARRAY OF INTEGER
03   LET a[50] = 12456
04   DISPLAY a[100]  -- Runtime error
05 END MAIN

Arrays can be queried with the getLength() method, to get the number of allocated elements:

01 MAIN
02   DEFINE a DYNAMIC ARRAY OF INTEGER
03   LET a[5000] = 12456
04   DISPLAY a.getLength()
05 END MAIN

You can insert a new element at a given position with the insertElement() method. The new element will be initialized to NULL. All subsequent elements are moved down by an offset of +1. Dynamic arrays will grow by 1, while static arrays will lose the last element:

01 MAIN
02   DEFINE a DYNAMIC ARRAY OF INTEGER
03   LET a[10] = 11
04   CALL a.insertElement(10)
05   LET a[10] = 10
06   DISPLAY a.getLength() -- shows 11
07   DISPLAY a[10]  -- shows 10
08   DISPLAY a[11]  -- shows 11
09 END MAIN

You can append a new element at the end of a dynamic array with the appendElement() method. The new element will be initialized to NULL. Dynamic arrays will grow by 1, while static arrays will not be affected by this method:

01 MAIN
02   DEFINE a DYNAMIC ARRAY OF INTEGER
03   LET a[10] = 10
04   CALL a.appendElement()
05   LET a[a.getLength()] = a.getLength()
06   DISPLAY a.getLength() -- shows 11
07   DISPLAY a[10]  -- shows 10
08   DISPLAY a[11]  -- shows 11
09 END MAIN

The deleteElement() method can be used to remove elements from a static or dynamic array. Subsequent elements are moved up by an offset of -1. Dynamic arrays will shrink by 1, while static arrays will have NULLs in the last element.

01 MAIN
02   DEFINE a DYNAMIC ARRAY OF INTEGER
03   LET a[10] = 9
04   CALL a.deleteElement(5)
06   DISPLAY a.getLength() -- shows 9
07   DISPLAY a[9]  -- shows 9
08 END MAIN

You can clear an array with the clear() method. When used on a static array, this method sets all elements to NULL. When used on a dynamic array, it removes all elements:

01 MAIN
02   DEFINE a DYNAMIC ARRAY OF INTEGER
03   LET a[10] = 11
04   DISPLAY a.getLength() -- shows 10
05   CALL a.clear()
06   DISPLAY a.getLength() -- shows 0
07 END MAIN

Array methods can be used on two- and three-dimensional arrays with the brackets notation:

01 MAIN
02   DEFINE a2 DYNAMIC ARRAY WITH DIMENSION 2 OF INTEGER
03   DEFINE a3 DYNAMIC ARRAY WITH DIMENSION 3 OF INTEGER
04   LET a2[50,100]  = 12456
05   LET a2[51,1000] = 12456
06   DISPLAY a2.getLength()         -- Displays 51
07   DISPLAY a2[50].getLength()     -- Displays 100
08   DISPLAY a2[51].getLength()     -- Displays 1000
09   LET a3[50,100,100]  = 12456
10   LET a3[51,101,1000] = 12456
11   DISPLAY a3.getLength()         -- Displays 51
12   DISPLAY a3[50].getLength()     -- Displays 100
13   DISPLAY a3[51].getLength()     -- Displays 101
14   DISPLAY a3[50,100].getLength() -- Displays 100
15   DISPLAY a3[51,101].getLength() -- Displays 1000
16   CALL a3[50].insertElement(10)  -- Inserts at 50,10
17   CALL a3[50,10].insertElement(1)-- Inserts at 50,10,1
18 END MAIN

Examples

Example 1:

01 MAIN
02   DEFINE a1 DYNAMIC ARRAY OF INTEGER
03   DEFINE a2 DYNAMIC ARRAY WITH DIMENSION 2 OF INTEGER
04   DEFINE a3 ARRAY[10,20] OF RECORD
05               id INTEGER,
06               name VARCHAR(100),
07               birth DATE
08            END RECORD
09   LET a1[5000] = 12456
10   LET a2[5000,300] = 12456
11   LET a3[5,1].id = a1[50]
12   LET a3[5,1].name = 'Scott'
13   LET a3[5,1].birth = TODAY
14 END MAIN