6.3.2INTO

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

# insert (i.e. write) values 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 return 65, 66, 67)
SELECT FROM my_dataset0

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

# select (i.e. read) data from dataset "my_dataset0" and write it into an HDF5 attribute named "my_attribute0" (if the attribute does not exist, it will be created automatically and of data type char of one dimension (size 3))
SELECT FROM my_dataset0 INTO ATTRIBUTE my_attribute0

# select (i.e. read) data from dataset "my_dataset0" and write it into a text file named "my_file0.txt" using default separator "," (should write "65,66,67" in one single line)
SELECT FROM my_dataset0 INTO FILE my_file0.txt

# select (i.e. read) data from dataset "my_dataset0" and write it into a text file named "my_file1.txt" using separator "**" (should write "65**66**67**" in one single line)
SELECT FROM my_dataset0 INTO TEXT FILE my_file1.txt SEPARATOR **

# select (i.e. read) data from dataset "my_dataset0" and write it into a text file named "my_file2.txt" splitting every two values on a new line using a UNIX-based EOL terminator (should write "65,65" in the first line and "67" in the second line)
SELECT FROM my_dataset0 INTO UNIX TEXT FILE my_file2.txt SPLIT 2

# select (i.e. read) data from dataset "my_dataset0" and write it into a binary file named "my_file.bin" (truncate it if it already exists) (should write "ABC")
SELECT FROM my_dataset0 INTO TRUNCATE BINARY FILE my_file.bin

# select (i.e. read) data from dataset "my_dataset0" and write it into an Excel file named "my_file0.xlsx" in the sheet currently selected for viewing/editing within the file (should write 65, 66, 67)
SELECT FROM my_dataset0 INTO EXCEL FILE my_file0.xlsx

# select (i.e. read) data from dataset "my_dataset0" and write it into an Excel file named "my_file1.xlsx" in a sheet named "my_sheet" (truncate it if it already exists) (should write 65, 66, 67)
SELECT FROM my_dataset0 INTO TRUNCATE EXCEL FILE my_file1.xlsx SHEET my_sheet

// create a chunked (size 1) HDF5 dataset named "my_dataset1" of data type int of two dimensions (size 3x2), and with initial values of 4 and 6 for the first position, 5 and 7 for the second position, and 8 and 9 for the third position
hdfql_execute("CREATE CHUNKED(1) DATASET my_dataset1 AS INT(3, 2) VALUES((4, 6), (5, 7), (8, 9))");

// prepare cursor in use to be populated with only one slice/portion of dataset "my_dataset1" at the time by sliding on its first dimension (each slice/portion has two elements)
hdfql_execute("SELECT FROM my_dataset1 INTO SLIDING CURSOR");

// move cursor in use to the next position (a new slice/portion of dataset "my_dataset1" is automatically read by HDFql (using a hyperslab selection under the hood) given that the cursor is positioned outside the slice/portion it currently stores)
hdfql_cursor_next(NULL); 

// display content of cursor in use (should be 4) 
printf("%d\n", *hdfql_cursor_get_int(NULL));

// move cursor in use to the next position (no new slice/portion of dataset "my_dataset1" is read given that the cursor is still positioned inside the slice/portion it currently stores)
hdfql_cursor_next(NULL); 

// display content of cursor in use (should be 6) 
printf("%d\n", *hdfql_cursor_get_int(NULL));

// move cursor in use to the next position (a new slice/portion of dataset "my_dataset1" is automatically read by HDFql (using a hyperslab selection under the hood) given that the cursor is positioned outside the slice/portion it currently stores)
hdfql_cursor_next(NULL); 

// display content of cursor in use (should be 5) 
printf("%d\n", *hdfql_cursor_get_int(NULL));

// move cursor in use to the next position (no new slice/portion of dataset "my_dataset1" is read given that the cursor is still positioned inside the slice/portion it currently stores)
hdfql_cursor_next(NULL); 

// display content of cursor in use (should be 7) 
printf("%d\n", *hdfql_cursor_get_int(NULL)); 

// move cursor in use to the next position (a new slice/portion of dataset "my_dataset1" is automatically read by HDFql (using a hyperslab selection under the hood) given that the cursor is positioned outside the slice/portion it currently stores)
hdfql_cursor_next(NULL); 

// display content of cursor in use (should be 8) 
printf("%d\n", *hdfql_cursor_get_int(NULL));

// move cursor in use to the next position (no new slice/portion of dataset "my_dataset1" is read given that the cursor is still positioned inside the slice/portion it currently stores)
hdfql_cursor_next(NULL); 

// display content of cursor in use (should be 9) 
printf("%d\n", *hdfql_cursor_get_int(NULL));

// declare variables 
char script[1024];
double data[3][2];
int x;
int y;

// create an HDF5 dataset named "my_dataset2" of data type double of two dimensions (size 3x2)
hdfql_execute("CREATE DATASET my_dataset2 AS DOUBLE(3, 2)");

// insert (i.e. write) values into dataset "my_dataset2" 
hdfql_execute("INSERT INTO my_dataset2 VALUES((3.2, 1.3), (0, 0.2), (9.1, 6.5))");

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

// prepare script to select (i.e. read) data from dataset "my_dataset2" and populate variable "data" with it
sprintf(script, "SELECT FROM my_dataset2 INTO 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); 

// display content of variable "data" (should be 3.2, 1.3, 0, 0.2, 9.1, 6.5) 
for(x = 0; x < 3; x++)
{
    for(y = 0; y < 2; y++)
    {
       printf("%d\n", data[x][y]);
    }
}

// declare variables 
char script[1024];
HDFQL_VARIABLE_LENGTH data[3];
int x; 
int y;
int count;

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

// insert (i.e. write) values into dataset "my_dataset3" 
hdfql_execute("INSERT INTO my_dataset3 VALUES((3.2, 1.3), (0, 0.2), (9.1, 7.4, 6.5))");

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

// prepare script to select (i.e. read) data from dataset "my_dataset3" and populate variable "data" with it
sprintf(script, "SELECT FROM my_dataset3 INTO 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); 

// display content of variable "data" (should be 3.2, 1.3, 0, 0.2, 9.1, 7.4, 6.5) 
for(x = 0; x < 3; x++)
{ 
    count = data[x].count;
    for(y = 0; y < count; y++)
    {
       printf("%f\n", *((double *) data[x].address + y));
    }
}

// release memory allocated (by HDFql) in variable "data" 
for(x = 0; x < 3; x++)
{ 
    free(data[x].address);
}

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

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

// insert (i.e. write) values into dataset "my_dataset4" 
hdfql_execute("INSERT INTO my_dataset4 VALUES(\"Hierarchical\", \"Data\", \"Format\")");

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

// prepare script to select (i.e. read) data from dataset "my_dataset4" and populate variable "data" with it
sprintf(script, "SELECT FROM my_dataset4 INTO 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); 

// display content of variable "data" (should be "Hierarchical", "Data", "Format") 
for(x = 0; x < 3; x++)
{ 
    printf("%s\n", data[x]);
}

// release memory allocated (by HDFql) in variable "data" 
for(x = 0; x < 3; x++)
{ 
    free(data[x]);
}

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

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

// create an HDF5 dataset named "my_dataset5" 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), and with initial values of "Toronto" and 10 for the first position, "Nairobi" and 12 for the second position, and "Caracas" and 11 for the third position
hdfql_execute("CREATE DATASET my_dataset5 AS COMPOUND(description AS CHAR(7), index AS INT)(3) VALUES((Toronto, 10), (Nairobi, 12), (Caracas, 11))");

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

// prepare script to select (i.e. read) data from dataset "my_dataset5" and populate variable "cities" with it
sprintf(script, "SELECT FROM my_dataset5 INTO 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); 

// display content of variable "cities" (should be "The city of Toronto has index 10", "The city of Nairobi has index 12", "The city of Caracas has index 11")
for(i = 0; i < 3; i++)
{
    printf("The city of %s has index %d\n", cities[i].description, cities[i].index);
}