6.5.1INSERT

# create an HDF5 dataset named "my_dataset0" of data type short of one dimension (size 3) 
CREATE DATASET my_dataset0 AS SMALLINT(3)

# create an HDF5 dataset named "my_dataset1" of data type int of one dimension (size 5) 
CREATE DATASET my_dataset1 AS INT(5)

# insert (i.e. write) values 65, 66, and 67 into dataset "my_dataset0" 
INSERT INTO my_dataset0 VALUES(65, 66, 67)

# select (i.e. read) data from dataset "my_dataset0" and populate cursor in use with it (should populate with 65, 66, 67)
SELECT FROM my_dataset0

# insert (i.e. write) values into dataset "my_dataset1" from cursor in use (should write 65, 66, 67, 0, 0)
INSERT INTO my_dataset1

# create an HDF5 attribute named "my_attribute0" of data type short 
CREATE ATTRIBUTE my_attribute0 AS SMALLINT 

# insert (i.e. write) value 95 into attribute "my_attribute0" 
INSERT INTO my_attribute0 VALUES(95)

# create an HDF5 attribute named "my_attribute1" of data type unsigned short of one dimension (size 2)
CREATE ATTRIBUTE my_attribute1 AS UNSIGNED SMALLINT(2)

# insert (i.e. write) values 95 and 97 into attribute "my_attribute1" 
INSERT INTO my_attribute1 VALUES(95, 97)

# create an HDF5 dataset named "my_dataset2" of data type float of one dimension (size 512) 
CREATE DATASET my_dataset2 AS FLOAT(512)

# insert (i.e. write) values into dataset "my_dataset2" from a text file named "my_file0.txt" that has values separated with "," (i.e. default separator)
INSERT INTO my_dataset2 VALUES FROM FILE my_file0.txt

# insert (i.e. write) values into dataset "my_dataset2" from a text file named "my_file1.txt" that has a DOS-based end-of-line (EOL) terminator and values separated with "**"
INSERT INTO my_dataset2 VALUES FROM DOS TEXT FILE my_file1.txt SEPARATOR **

# insert (i.e. write) values into dataset "my_dataset2" from a binary file named "my_file.bin"
INSERT INTO my_dataset2 VALUES FROM BINARY FILE my_file.bin

# create an HDF5 dataset named "my_dataset3" of data type short of one dimension (size 5) 
CREATE DATASET my_dataset3 AS SMALLINT(5)

# insert (i.e. write) value 9 into position #3 of dataset "my_dataset3" using a hyperslab selection
INSERT INTO my_dataset3[3:::] VALUES(9)

# select (i.e. read) data from dataset "my_dataset3" and populate cursor in use with it (should populate with 0, 0, 0, 9, 0)
SELECT FROM my_dataset3

# insert (i.e. write) value 9 into position #4 of dataset "my_dataset3" using a hyperslab selection
INSERT INTO my_dataset3[-1:::] VALUES(7)

# select (i.e. read) data from dataset "my_dataset3" and populate cursor in use with it (should populate with 0, 0, 0, 9, 7)
SELECT FROM my_dataset3

# insert (i.e. write) values 5 and 3 into positions #1 and #2 of dataset "my_dataset3" using a hyperslab selection
INSERT INTO my_dataset3[1:::2] VALUES(5, 3)

# select (i.e. read) data from dataset "my_dataset3" and populate cursor in use with it (should populate with 0, 5, 3, 9, 7)
SELECT FROM my_dataset3

# create an HDF5 dataset named "my_dataset4" of data type int of two dimensions (size 3x3) 
CREATE DATASET my_dataset4 AS INT(3, 3)

# insert (i.e. write) value 8 into position #2 of the first dimension and position #1 of the second dimension of dataset "my_dataset4" using a hyperslab selection
INSERT INTO my_dataset4[2:::, 1:::] VALUES(8)

# select (i.e. read) data from dataset "my_dataset4" and populate cursor in use with it (should populate with 0, 0, 0, 0, 0, 0, 0, 8, 0)
SELECT FROM my_dataset4

# insert (i.e. write) value 4 into position #2 of the first dimension and position #0 of the second dimension, and value 6 into position #2 of the first dimension and position #2 of the second dimension of dataset "my_dataset4" using a hyperslab selection
INSERT INTO my_dataset4[2:::, 0:2:2:1] VALUES(4, 6)

# select (i.e. read) data from dataset "my_dataset4" and populate cursor in use with it (should populate with 0, 0, 0, 0, 0, 0, 4, 8, 6)
SELECT FROM my_dataset4

# create an HDF5 dataset named "my_dataset5" of data type short of one dimension (size 10) 
CREATE DATASET my_dataset5 AS SMALLINT(10)

# insert (i.e. write) values 90, 91, and 92 into positions #2, #3, and #4, respectively, value 93 into position #5, and values 94 and 95 into positions #7 and #8, respectively, of dataset "my_dataset5" using an irregular hyperslab selection
INSERT INTO my_dataset5[2::3:1 OR 4::2:1 OR 7::2:1] VALUES(90, 91, 92, 93, 94, 95)

# select (i.e. read) data from dataset "my_dataset5" and populate cursor in use with it (should populate with 0, 0, 90, 91, 92, 93, 0, 94, 95, 0)
SELECT FROM my_dataset5

# create an HDF5 dataset named "my_dataset6" of data type long long of one dimension (size 15)
CREATE DATASET my_dataset6 AS BIGINT(15)

# insert (i.e. write) values 75 and 77 into positions #5 and #6, respectively, of dataset "my_dataset6" using an irregular hyperslab selection
INSERT INTO my_dataset6[3::4:1 AND 5::3:1] VALUES(75, 77, 79, 81, 83, 85, 87)

# select (i.e. read) data from dataset "my_dataset6" and populate cursor in use with it (should populate with 0, 0, 0, 0, 0, 75, 77, 0, 0, 0, 0, 0, 0, 0, 0)
SELECT FROM my_dataset6

# create an HDF5 dataset named "my_dataset7" of data type float of one dimension (size 8) 
CREATE DATASET my_dataset7 AS FLOAT(8)

# insert (i.e. write) values 7.5, 7.7, and 7.9 into positions #2, #4, and #7, respectively, of dataset "my_dataset7" using a point selection
INSERT INTO my_dataset7[2; 4; 7] VALUES(7.5, 7.7, 7.9)

# select (i.e. read) data from dataset "my_dataset7" and populate cursor in use with it (should populate with 0, 0, 7.5, 0, 7.7, 0, 0, 7.9)
SELECT FROM my_dataset7

# create an HDF5 dataset named "my_dataset8" of data type double of two dimensions (size 4x3)
CREATE DATASET my_dataset8 AS DOUBLE(4, 3)

# insert (i.e. write) value 15.2 into position #1 of the first dimension and position #2 of the second dimension, and value 18.5 into position #3 of the first dimension and position #0 of the second dimension of dataset "my_dataset8" using a point selection
INSERT INTO my_dataset8[1, 2; 3, 0] VALUES(15.2, 18.5)

# select (i.e. read) data from dataset "my_dataset8" and populate cursor in use with it (should populate with 0, 0, 0, 0, 0, 15.2, 0, 0, 0, 18.5, 0, 0)
SELECT FROM my_dataset8

# use (i.e. open) an HDF5 file named "my_file.h5" 
USE FILE my_file.h5

# create an HDF5 dataset named "my_dataset9" of data type double in the HDF5 file currently in use (i.e. file "my_file.h5")
CREATE DATASET my_dataset9 AS DOUBLE

# insert (i.e. write) value 6.5 into dataset "my_dataset9" 
INSERT INTO my_dataset9 VALUES(6.5)

# select (i.e. read) data from dataset "my_dataset9" and populate cursor in use with it (should populate with 6.5)
SELECT FROM my_dataset9

# close HDF5 file currently in use (i.e. file "my_file.h5") 
CLOSE FILE 

# insert (i.e. write) value 3.2 into dataset "my_dataset9" in file "my_file.h5" 
INSERT INTO my_file.h5 my_dataset9 VALUES(3.2)

# select (i.e. read) data from dataset "my_dataset9" in file "my_file.h5" and populate cursor in use with it (should populate with 3.2)
SELECT FROM my_file.h5 my_dataset9

# create an HDF5 dataset named "my_dataset10" of data type enumeration composed of three members named "helium" (with value 0), "oxygen" (with value 1), and "argon" (with value 2)
CREATE DATASET my_dataset10 AS ENUMERATION(helium, oxygen, argon)

# insert (i.e. write) value 1 (i.e. "oxygen") into dataset "my_dataset10" 
INSERT INTO my_dataset10 VALUES(oxygen)

# select (i.e. read) data from dataset "my_dataset10" and populate cursor in use with it (should populate with 1 (i.e. "oxygen"))
SELECT FROM my_dataset10

# create an HDF5 attribute named "my_attribute2" of data type enumeration of one dimension (size 4) composed of three members named "red" (with value 0), "green" (with value 50), and "blue" (with value 51)
CREATE ATTRIBUTE my_attribute2 AS ENUMERATION(red, green AS 50, blue)(4)

# insert (i.e. write) values 51 (i.e. "blue"), "red" (i.e. 0), "green" (i.e. 50), and "blue" (i.e. 51) into attribute "my_attribute2"
INSERT INTO my_attribute2 VALUES(51, red, green, blue)

# select (i.e. read) data from attribute "my_attribute2" and populate cursor in use with it (should populate with 51 (i.e. "blue"), 0 (i.e. "red"), 50 (i.e. "green"), 51 (i.e. "blue"))
SELECT FROM my_attribute2

# create a chunked (size 2) HDF5 dataset named "my_dataset11" of data type int of one dimension (size 6)
CREATE CHUNKED(2) DATASET my_dataset11 AS INT(6)

# insert (i.e. write) values 60 and 61 directly into chunk #0 of dataset "my_dataset11" using a (filter) mask equal to 8
INSERT DIRECTLY MASK 8 INTO my_dataset11 VALUES(60, 61)

# insert (i.e. write) values 62 and 63 directly into chunk #1 of dataset "my_dataset11" using a (filter) mask equal to 255 (i.e. 0xFF)
INSERT DIRECTLY MASK 0xFF INTO my_dataset11[1] VALUES(62, 63)

# insert (i.e. write) values 64 and 65 directly into chunk #2 of dataset "my_dataset11" using a (filter) mask equal to 0 (i.e. default value)
INSERT DIRECTLY INTO my_dataset11[2] VALUES(64, 65)

# select (i.e. read) data from dataset "my_dataset11" and populate cursor in use with it (should populate with 60, 61, 62, 63, 64, 65)
SELECT FROM my_dataset11

// declare variables 
char script[1024];
double data[3];

// create an HDF5 dataset named "my_dataset12" of data type double of one dimension (size 3) 
hdfql_execute("CREATE DATASET my_dataset12 AS DOUBLE(3)");

// populate variable "data" with certain values 
data[0] = 21.1; 
data[1] = 18.8;
data[2] = 75.6;

// register variable "data" for subsequent use (by HDFql) 
hdfql_variable_register(data);

// prepare script to insert (i.e. write) values from variable "data" into dataset "my_dataset12"
sprintf(script, "INSERT INTO my_dataset12 VALUES FROM MEMORY %d", hdfql_variable_get_number(data));

// execute script 
hdfql_execute(script);

// unregister variable "data" as it is no longer used/needed (by HDFql) 
hdfql_variable_unregister(data); 

// declare variables 
char script[1024];
HDFQL_VARIABLE_LENGTH data[3];

// create an HDF5 dataset named "my_dataset13" of data type variable-length double of one dimension (size 3)
hdfql_execute("CREATE DATASET my_dataset13 AS VARDOUBLE(3)");

// allocate memory in variable "data" 
data[0].address = malloc(2 * sizeof(double)); 
data[0].count = 2;
data[1].address = malloc(3 * sizeof(double)); 
data[1].count = 3;
data[2].address = malloc(1 * sizeof(double)); 
data[2].count = 1;

// populate variable "data" with certain values 
*((double *) data[0].address + 0) = 3.2; 
*((double *) data[0].address + 1) = 1.3; 
*((double *) data[1].address + 0) = 0; 
*((double *) data[1].address + 1) = 0.2; 
*((double *) data[1].address + 2) = 9.1; 
*((double *) data[2].address + 0) = 6.5; 

// register variable "data" for subsequent use (by HDFql) 
hdfql_variable_register(data);

// prepare script to insert (i.e. write) values from variable "data" into dataset "my_dataset13"
sprintf(script, "INSERT INTO my_dataset13 VALUES FROM MEMORY %d", hdfql_variable_get_number(data));

// execute script 
hdfql_execute(script);

// unregister variable "data" as it is no longer used/needed (by HDFql) 
hdfql_variable_unregister(data); 

// select (i.e. read) data from dataset "my_dataset13" and populate cursor in use with it 
hdfql_execute("SELECT FROM my_dataset13");

// display content of cursor in use (should be 3.2, 1.3, 0, 0.2, 9.1, 6.5) 
while(hdfql_cursor_next(NULL) == HDFQL_SUCCESS)
{
    while(hdfql_subcursor_next(NULL) == HDFQL_SUCCESS)
    {
       printf("%f\n", *hdfql_subcursor_get_double(NULL));
    }
}

// release memory allocated in variable "data" 
free(data[0].address);
free(data[1].address);
free(data[2].address);

// declare variables 
char script[1024];
char *data[3];

// create an HDF5 dataset named "my_dataset14" of data type variable-length char of one dimension (size 3)
hdfql_execute("CREATE DATASET my_dataset14 AS VARCHAR(3)");

// allocate memory in variable "data" 
data[0] = malloc(13 * sizeof(char)); 
data[1] = malloc(5 * sizeof(char)); 
data[2] = malloc(7 * sizeof(char)); 

// populate variable "data" with certain values 
strcpy(data[0], "Hierarchical"); 
strcpy(data[1], "Data"); 
strcpy(data[2], "Format"); 

// register variable "data" for subsequent use (by HDFql) 
hdfql_variable_register(data);

// prepare script to insert (i.e. write) values from variable "data" into dataset "my_dataset14"
sprintf(script, "INSERT INTO my_dataset14 VALUES FROM MEMORY %d", hdfql_variable_get_number(data));

// execute script 
hdfql_execute(script);

// unregister variable "data" as it is no longer used/needed (by HDFql) 
hdfql_variable_unregister(data); 

// select (i.e. read) data from dataset "my_dataset14" and populate cursor in use with it 
hdfql_execute("SELECT FROM my_dataset14");

// display content of cursor in use (should be "Hierarchical", "Data", "Format") 
while(hdfql_cursor_next(NULL) == HDFQL_SUCCESS)
{
    printf("%s\n", hdfql_cursor_get_char(NULL));
}

// release memory allocated in variable "data" 
free(data[0]);
free(data[1]);
free(data[2]);

// declare structure 
struct coordinate
{
   double latitude; 
   double longitude; 
};

// declare variables 
char script[1024];
struct coordinate location;

// create an HDF5 attribute named "my_attribute3" of data type compound composed of two members named "latitude" (of data type double) and "longitude" (of data type double)
hdfql_execute("CREATE ATTRIBUTE my_attribute3 AS COMPOUND(latitude AS DOUBLE, longitude AS DOUBLE)");

// populate variable "location" with certain values 
location.latitude = 15.9803486587; 
location.longitude = 48.6352028395;

// prepare script to insert (i.e. write) values from variable "location" into attribute "my_attribute3"
sprintf(script, "INSERT INTO my_attribute3 VALUES FROM MEMORY %d", hdfql_variable_transient_register(&location));

// execute script 
hdfql_execute(script);

// declare structure 
struct data
{ 
   char description[7]; 
   int index; 
};

// declare variables 
char script[1024];
struct data cities[3]; 
int number;

// create an HDF5 dataset named "my_dataset15" of data type compound of one dimension (size 3) composed of two members named "description" (of data type char) and "index" (of data type int)
hdfql_execute("CREATE DATASET my_dataset15 AS COMPOUND(description AS CHAR(7), index AS INT)(3)");

// populate variable "cities" with certain values 
memcpy(cities[0].description, "Toronto", 7);
cities[0].index = 10; 
memcpy(cities[1].description, "Nairobi", 7);
cities[1].index = 12; 
memcpy(cities[2].description, "Caracas", 7);
cities[2].index = 11; 

// register variable "cities" for subsequent use (by HDFql) 
number = hdfql_variable_register(cities);

// prepare script to insert (i.e. write) values from variable "cities" into dataset "my_dataset15"
sprintf(script, "INSERT INTO my_dataset15 VALUES FROM MEMORY %d SIZE %d OFFSET(%d, %d)", number, sizeof(struct data), offsetof(struct data, description), offsetof(struct data, index));

// execute script 
hdfql_execute(script); 

// unregister variable "cities" as it is no longer used/needed (by HDFql) 
hdfql_variable_unregister(cities);

// assume that the following program is launched in parallel using four MPI processes (e.g. "mpiexec -n 4 ./my_program")

// declare variables 
char script[1024]; 
int rank;

// create an HDF5 file named "my_file.h5" in parallel 
hdfql_execute("CREATE FILE my_file.h5 IN PARALLEL");

// use (i.e. open) HDF5 file "my_file.h5" in parallel 
hdfql_execute("USE FILE my_file.h5 IN PARALLEL");

// create an HDF5 dataset named "my_dataset16" of data type int of one dimension (size 4) 
hdfql_execute("CREATE DATASET my_dataset16 AS INT(4)");

// get rank of the MPI process (should be between 0 and 3) 
rank = hdfql_mpi_get_rank();

// prepare script to insert (i.e. write) values 0, 10, 20, and 30 in parallel into positions #0 (by MPI process rank 0), #1 (by MPI process rank 1), #2 (by MPI process rank 2) and #3 (by MPI process rank 3), respectively, of dataset "my_dataset16" using a point selection
sprintf(script, "INSERT INTO my_dataset16[%d] IN PARALLEL VALUES(%d)", rank, rank * 10);

// execute script 
hdfql_execute(script);