/* Starts timer for given tag. If it does not exist yet,
it is added.
Note: 1. The tag may not be nested with the same name
2. The tag may not equal "" */
void ProfileStart (char* str_tag) {
entry_t* p_entry ;
/* One the first call, we must initialize the profiler. */
if (!g_init) {
Init () ;
}
/* Test for "" */
if (*str_tag == '\0') {
fprintf (stdout, "ERROR in ProfileStart: a tag may not be \"\". Call is denied.") ;
return ;
}
/* Search the entry with the given name */
p_entry = LookupTag (str_tag) ;
if (!p_entry) {
/* New tag, add it*/
p_entry = AddTag (str_tag) ;
if (!p_entry) {
fprintf (stdout, "WARNING in ProfileStart: no more space to store the tag (\"%s\"). Increase NUM_TAGS in \"profile.h\". Call is denied.\n", str_tag) ;
return ;
}
}
/* Check for nesting of equal tag.*/
if (Nested (str_tag)) {
fprintf (stdout, "ERROR in ProfileStart: nesting of equal tags not allowed (\"%s\"). Call is denied.\n", str_tag) ;
return ;
}
/* Increase the number of hits */
++p_entry->i_calls ;
/* Set the start time */
p_entry->start_time = clock () ;
p_entry->i_stopped = 0 ;
}
namespace InClassInitializers {
// Noexcept::Noexcept() is implicitly declared as noexcept(false), because it
// directly invokes ThrowSomething(). However...
//
// If noexcept(Noexcept()) is false, then Noexcept() is a constant expression,
// so noexcept(Noexcept()) is true. But if noexcept(Noexcept()) is true, then
// Noexcept::Noexcept is not declared constexpr, therefore noexcept(Noexcept())
// is false.
bool ThrowSomething() noexcept(false);
struct ConstExpr {
bool b = noexcept(ConstExpr()) && ThrowSomething(); // expected-error {{exception specification is not available until end of class definition}}
};
// We can use it now.
bool w = noexcept(ConstExpr());
// Much more obviously broken: we can't parse the initializer without already
// knowing whether it produces a noexcept expression.
struct TemplateArg {
int n = ExceptionIf<noexcept(TemplateArg())>::f(); // expected-error {{exception specification is not available until end of class definition}}
};
bool x = noexcept(TemplateArg());
// And within a nested class.
struct Nested {
struct Inner {
int n = ExceptionIf<noexcept(Nested())>::f(); // expected-error {{exception specification is not available until end of class definition}}
} inner;
};
bool y = noexcept(Nested());
bool z = noexcept(Nested::Inner());
}
Db_Record::~Db_Record (void)
{
Record_Size (0);
if (Nested ()) {
Nest (!Nest ());
Record_Size (0);
}
}
void Db_Record::Record_Format (Format_Type format)
{
if (format == DEFAULT_FORMAT) {
format = (Format_Type) Default_Format ();
}
record_format = format;
switch (record_format) {
case DBASE:
record_format = FIXED_COLUMN;
break;
case COMMA_DELIMITED:
delimiters = comma_delimiter;
break;
case SPACE_DELIMITED:
delimiters = space_delimiter;
break;
case VERSION3:
record_format = TAB_DELIMITED;
case TAB_DELIMITED:
delimiters = tab_delimiter;
break;
case SQLITE3:
record_format = BINARY;
break;
default: //---- CSV ----
delimiters = csv_delimiter;
break;
}
if (record_format == BINARY || record_format == FIXED_COLUMN) {
Record_Size (0);
if (Nested ()) {
Nest (!Nest ());
Record_Size (0);
}
} else {
Record_Size (4080);
if (Nested ()) {
Nest (!Nest ());
Record_Size (4080);
}
}
}
char * Db_Base::Reset_Record (void)
{
if (File_Format () == CSV_DELIMITED) {
Field_Itr itr;
for (itr = field.begin (); itr != field.end (); itr++) {
if (Nested () == itr->Nested ()) {
itr->Buffer ().erase ();
}
}
}
return (Db_Record::Reset_Record ().Data ());
}
void Db_Base::Blank_Field (Db_Field *fld)
{
if (fld == 0) return;
if (Record_Format () == BINARY || Record_Format () == FIXED_COLUMN) {
Nested (fld->Nested ());
char *field = Record_String ();
field += fld->Offset ();
memset (field, ' ', fld->Width ());
} else {
fld->Buffer ().erase ();
}
}
bool Db_File::Write (bool nested)
{
if (!nested && Nest () == FLATTEN) return (true);
Nested (nested);
return (Write ());
}
int Db_Base::Add_Field (const char *name, Field_Type type, double size, Units_Type units, bool binary, Nest_Type nest, int offset)
{
if (Dbase_Format () == DEFAULT_FORMAT) {
Dbase_Format (DEFAULT_FORMAT);
}
if (field.capacity () == 0) {
field.reserve (10);
}
if (time_format == NO_UNITS) {
time_format = Static_Service::Time_Format ();
if (type == DB_TIME && units == NO_UNITS) {
units = time_format;
}
}
int length, num;
Field_Itr itr;
switch (Dbase_Format ()) {
case COMMA_DELIMITED:
case SPACE_DELIMITED:
case TAB_DELIMITED:
case CSV_DELIMITED:
case VERSION3:
num = 1;
length = 0;
for (itr = field.begin (); itr != field.end (); itr++) {
if ((nest != NESTED && !itr->Nested ()) || itr->Nest () == nest) {
length += itr->Width () + 1;
num++;
}
}
if (binary) {
Binary_Text_Size (type, &size);
}
length += (int) size;
if (offset <= 0) offset = num;
break;
case UNFORMATED:
case BINARY:
case FIXED_COLUMN:
case DBASE:
case ARCVIEW:
case SQLITE3:
case TPPLUS:
case TRANSCAD:
default:
if (offset < 0) {
offset = (Dbase_Format () == DBASE || Dbase_Format () == ARCVIEW) ? 1 : 0;
for (itr = field.begin (); itr != field.end (); itr++) {
if ((nest != NESTED && !itr->Nested ()) || itr->Nest () == nest) {
length = itr->Offset () + itr->Width ();
if (offset < length) offset = length;
}
}
}
if (binary) {
if (Record_Format () != BINARY) {
Binary_Text_Size (type, &size);
}
} else if (Record_Format () == BINARY) {
Text_Binary_Size (type, &size);
}
if (type == DB_TIME && Record_Format () == BINARY) {
units = SECONDS;
}
length = offset + (int) size;
break;
}
//---- convert to internal units ----
if (File_Access () == CREATE) Internal_Units (1.0, &units);
Db_Field fld (name, type, offset, size, units, nest);
num = (int) field.size ();
field.push_back (fld);
Nested (nest);
if (!Record_Size (length)) return (-1);
return (num);
}
bool Db_Base::Write_Field (Db_Field *fld, void *data, Field_Type type)
{
if (data == 0) return (Status (NULL_POINTER));
if (fld == 0) return (Status (NO_FIELD, false));
if (!Record ().OK ()) return (Status (RECORD_SIZE));
int lvalue = 0;
unsigned uvalue = 0;
double dvalue = 0.0;
Dtime tvalue;
String svalue;
Field_Type fld_type;
//---- convert the input data type to generic variables ----
fld_type = fld->Type ();
switch (fld_type) {
default:
return (Status (DB_ERROR));
case DB_INTEGER:
switch (type) {
case DB_INTEGER:
lvalue = *((int *) data);
break;
case DB_DOUBLE:
dvalue = *((double *) data);
if (dvalue > MAX_INTEGER) {
lvalue = MAX_INTEGER;
} else if (dvalue < -MAX_INTEGER) {
lvalue = -MAX_INTEGER;
} else {
lvalue = DTOI (dvalue);
}
break;
case DB_STRING:
lvalue = ((String *) data)->Integer ();
break;
case DB_TIME:
lvalue = (int) (*((Dtime *) data));
break;
default:
return (Status (DB_ERROR));
}
break;
case DB_UNSIGNED:
switch (type) {
case DB_INTEGER:
uvalue = *((unsigned *) data);
break;
case DB_DOUBLE:
dvalue = *((double *) data);
if (dvalue > 2.0 * MAX_INTEGER) {
uvalue = MAX_INTEGER;
uvalue *= 2;
} else if (dvalue < 0.0) {
uvalue = 0;
} else {
uvalue = (unsigned) (dvalue + 0.5);
}
break;
case DB_STRING:
uvalue = ((String *) data)->Integer ();
break;
case DB_TIME:
uvalue = (unsigned) (*((Dtime *) data));
break;
default:
return (Status (DB_ERROR));
}
break;
case DB_FIXED:
case DB_DOUBLE:
switch (type) {
case DB_INTEGER:
dvalue = (double) *((int *) data);
break;
case DB_DOUBLE:
dvalue = *((double *) data);
break;
case DB_STRING:
dvalue = ((String *) data)->Double ();
break;
case DB_TIME:
dvalue = (double) *((Dtime *) data);
break;
default:
return (Status (DB_ERROR));
}
break;
case DB_STRING:
case DB_CHAR:
switch (type) {
case DB_INTEGER:
if (fld->Units () >= FACILITY_CODE) {
External_Units (*((int *) data), fld->Units (), svalue);
} else {
svalue (*((int *) data));
}
break;
case DB_DOUBLE:
svalue (*((double *) data), fld->Decimal ());
break;
case DB_STRING:
svalue = *((string *) data);
break;
case DB_TIME:
svalue = ((Dtime *) data)->Time_String (fld->Units ());
break;
default:
return (Status (DB_ERROR));
}
break;
case DB_TIME:
switch (type) {
case DB_INTEGER:
tvalue = *((int *) data);
break;
case DB_DOUBLE:
tvalue = *((double *) data);
break;
case DB_STRING:
tvalue = *((string *) data);
break;
case DB_TIME:
tvalue = *((Dtime *) data);
break;
default:
return (Status (DB_ERROR));
}
break;
}
//---- convert to external units ----
if (fld->Units () != NO_UNITS) {
if (fld_type == DB_INTEGER) {
lvalue = (int) External_Units (lvalue, fld->Units ());
} else if (fld_type == DB_UNSIGNED) {
uvalue = (unsigned) External_Units ((int) uvalue, fld->Units ());
} else if (fld_type == DB_DOUBLE || fld_type == DB_FIXED) {
dvalue = External_Units (dvalue, fld->Units ());
} else if ((fld_type == DB_STRING || fld_type == DB_CHAR) && fld->Units () < FACILITY_CODE) {
return (Status (FIELD_UNITS));
}
}
//---- place the data onto the data record -----
Nested (fld->Nested ());
char *field = Record_String ();
bool asc_flag = false;
bool justify = false;
int len, position;
int size = fld->Width ();
int offset = fld->Offset ();
switch (Record_Format ()) {
case BINARY:
field += offset;
asc_flag = false;
break;
case FIXED_COLUMN:
field += offset;
memset (field, ' ', size);
asc_flag = justify = true;
break;
case COMMA_DELIMITED:
case SPACE_DELIMITED:
case TAB_DELIMITED:
case CSV_DELIMITED:
default:
asc_flag = true;
justify = false;
break;
}
switch (fld_type) {
default:
return (Status (DB_ERROR));
case DB_INTEGER:
if (asc_flag) {
svalue (lvalue);
if (justify) {
len = (int) svalue.size ();
position = size - len;
if (position < 0) {
position = 0;
len = size;
}
memcpy (field + position, svalue.c_str (), len);
}
} else if (size == sizeof (int)) {
*((int *) field) = lvalue;
} else if (size == sizeof (short)) {
if (lvalue > 32767) lvalue = 32767;
*((short *) field) = (short) lvalue;
} else if (size == sizeof (char)) {
if (lvalue > 127) lvalue = 127;
*((char *) field) = (char) lvalue;
} else {
return (Status (FIELD_BYTES));
}
break;
case DB_UNSIGNED:
if (asc_flag) {
svalue ((size_t) uvalue);
if (justify) {
len = (int) svalue.size ();
position = size - len;
if (position < 0) {
position = 0;
len = size;
}
memcpy (field + position, svalue.c_str (), len);
}
} else if (size == sizeof (int)) {
*((unsigned int *) field) = (unsigned int) uvalue;
} else if (size == sizeof (short)) {
if (uvalue > 65535) uvalue = 65535;
*((unsigned short *) field) = (unsigned short) uvalue;
} else if (size == sizeof (char)) {
if (uvalue > 255) uvalue = 255;
*((unsigned char *) field) = (unsigned char) uvalue;
} else {
return (Status (FIELD_BYTES));
}
break;
case DB_DOUBLE:
if (asc_flag) {
svalue (dvalue, fld->Decimal ());
if (justify) {
len = (int) svalue.size ();
position = size - len;
if (position < 0) {
position = 0;
len = size;
}
memcpy (field + position, svalue.c_str (), len);
}
} else if (size == sizeof (double)) {
*((double *) field) = dvalue;
} else if (size == sizeof (float)) {
*((float *) field) = (float) dvalue;
} else {
return (Status (FIELD_BYTES));
}
break;
case DB_FIXED:
if (asc_flag) {
svalue (dvalue, fld->Decimal ());
if (justify) {
len = (int) svalue.size ();
position = size - len;
if (position < 0) {
position = 0;
len = size;
}
memcpy (field + position, svalue.c_str (), len);
}
} else {
if (dvalue < 0.0) {
lvalue = (int) (dvalue * pow (10.0, fld->Decimal ()) - 0.5);
} else {
lvalue = (int) (dvalue * pow (10.0, fld->Decimal ()) + 0.5);
}
if (size == sizeof (int)) {
*((int *) field) = lvalue;
} else if (size == sizeof (short)) {
*((short *) field) = (short) lvalue;
} else if (size == sizeof (char)) {
*((char *) field) = (char) lvalue;
} else {
return (Status (FIELD_BYTES));
}
}
break;
case DB_STRING:
if (asc_flag) {
if (justify) {
len = (int) svalue.size ();
if (len > size) len = size;
memcpy (field, svalue.c_str (), len);
}
} else {
memset (field, '\0', size);
memcpy (field, svalue.c_str (), MIN ((int) svalue.size (), size));
}
break;
case DB_CHAR:
if (!asc_flag || justify) {
memset (field, '\0', size);
field [0] = svalue [0];
}
break;
case DB_TIME:
if (asc_flag) {
svalue = tvalue.Time_String (fld->Units ());
if (justify) {
len = (int) svalue.size ();
if (len > size) len = size;
memcpy (field, svalue.c_str (), len);
}
} else if (size == sizeof (Dtime)) {
*((Dtime *) field) = tvalue;
} else if (size == sizeof (short)) {
*((short *) field) = (short) tvalue;
} else {
return (Status (FIELD_BYTES));
}
break;
}
if (asc_flag && !justify) {
if (Record_Format () == UNFORMATED) {
return (Set_Field_Number (offset, svalue));
} else {
fld->Buffer (svalue);
}
}
return (true);
}
bool Db_Base::Read_Field (Db_Field *fld, void *data, Field_Type type)
{
if (data == 0) return (Status (NULL_POINTER));
//---- initialize the data field ----
switch (type) {
case DB_INTEGER:
*((int *) data) = 0;
break;
case DB_DOUBLE:
*((double *) data) = 0.0;
break;
case DB_STRING:
((string *) data)->clear ();
break;
case DB_TIME:
*((Dtime *) data) = 0;
break;
default:
return (Status (DB_ERROR));
}
if (fld == 0) return (Status (NO_FIELD, false));
Nested (fld->Nested ());
char *field = Record_String ();
if (field == 0) return (Status (RECORD_SIZE));
Field_Type fld_type;
bool asc_flag = true;
int len, lvalue = 0;
double dvalue = 0.0;
String svalue;
Dtime tvalue = 0;
int size = fld->Width ();
int offset = fld->Offset ();
switch (Record_Format ()) {
case BINARY:
if (fld->Type () != DB_STRING) {
field += offset;
asc_flag = false;
break;
} else {
len = (int) strlen (field + offset);
if (len < size) size = len;
}
case FIXED_COLUMN:
svalue.assign (field + offset, size);
svalue.Clean ();
break;
case COMMA_DELIMITED:
case SPACE_DELIMITED:
case TAB_DELIMITED:
case CSV_DELIMITED:
svalue (fld->Buffer ());
size = (int) svalue.size ();
break;
default:
svalue = Get_Field_Number (offset);
size = (int) svalue.size ();
break;
}
//---- read the field from the current record ----
switch (fld->Type ()) {
default:
return (Status (DB_ERROR));
case DB_INTEGER:
if (asc_flag) {
lvalue = svalue.Integer ();
} else if (size == sizeof (int)) {
lvalue = *((int *) field);
} else if (size == sizeof (short)) {
lvalue = *((short *) field);
} else if (size == sizeof (char)) {
lvalue = *((char *) field);
} else {
return (Status (FIELD_BYTES));
}
fld_type = DB_INTEGER;
break;
case DB_UNSIGNED:
if (asc_flag) {
lvalue = svalue.Integer ();
} else if (size == sizeof (int)) {
lvalue = *((unsigned int *) field);
} else if (size == sizeof (short)) {
lvalue = *((unsigned short *) field);
} else if (size == sizeof (char)) {
lvalue = *((unsigned char *) field);
} else {
return (Status (FIELD_BYTES));
}
fld_type = DB_INTEGER;
break;
case DB_DOUBLE:
if (asc_flag) {
dvalue = svalue.Double ();
} else if (size == sizeof (double)) {
dvalue = *((double *) field);
} else if (size == sizeof (float)) {
dvalue = *((float *) field);
} else {
return (Status (FIELD_BYTES));
}
fld_type = DB_DOUBLE;
break;
case DB_FIXED:
if (asc_flag) {
dvalue = svalue.Double ();
if (svalue.find ('.') == 0) {
dvalue = dvalue / pow (10.0, fld->Decimal ());
}
} else {
if (size == sizeof (int)) {
lvalue = *((int *) field);
} else if (size == sizeof (short)) {
lvalue = *((short *) field);
} else if (size == sizeof (char)) {
lvalue = *((char *) field);
} else {
return (Status (FIELD_BYTES));
}
dvalue = (double) lvalue / pow (10.0, fld->Decimal ());
}
fld_type = DB_DOUBLE;
break;
case DB_STRING:
fld_type = DB_STRING;
break;
case DB_CHAR:
if (asc_flag) {
if (svalue.empty ()) {
svalue = " ";
}
} else {
if (*field == '\0') {
svalue = " ";
} else {
svalue.insert (0, field, 1);
}
}
fld_type = DB_STRING;
break;
case DB_TIME:
if (asc_flag) {
tvalue.Time_String (svalue, fld->Units ());
} else if (size == sizeof (Dtime)) {
tvalue = *((int *) field);
} else if (size == sizeof (short)) {
tvalue = *((short *) field);
} else {
return (Status (FIELD_BYTES));
}
fld_type = DB_TIME;
break;
}
//---- convert to internal units ----
if (fld->Units () != NO_UNITS) {
if (fld_type == DB_INTEGER) {
lvalue = Internal_Units (lvalue, fld->Units ());
} else if (fld_type == DB_DOUBLE) {
dvalue = Internal_Units (dvalue, fld->Units ());
} else if (fld->Units () < SECONDS || fld->Units () > TIME_CODE) {
if (fld_type == DB_STRING && fld->Units () >= FACILITY_CODE) {
if (type == DB_INTEGER) {
lvalue = Internal_Units (svalue, fld->Units ());
if (lvalue < -1) return (Status (FIELD_UNITS));
if (lvalue >= 0) fld_type = DB_INTEGER;
}
} else {
return (Status (FIELD_UNITS));
}
}
}
//---- convert to the output data type ----
switch (type) {
case DB_INTEGER:
switch (fld_type) {
case DB_INTEGER:
*((int *) data) = lvalue;
break;
case DB_DOUBLE:
*((int *) data) = DTOI (dvalue);
break;
case DB_STRING:
if (svalue [0] < '0' || svalue [0] > '9' || svalue.find_first_of ("@:") != svalue.npos) {
*((int *) data) = (int) Dtime (svalue);
} else {
*((int *) data) = svalue.Integer ();
}
break;
case DB_TIME:
*((int *) data) = (int) tvalue;
break;
default:
return (Status (DB_ERROR));
}
break;
case DB_DOUBLE:
switch (fld_type) {
case DB_INTEGER:
*((double *) data) = lvalue;
break;
case DB_DOUBLE:
*((double *) data) = dvalue;
break;
case DB_STRING:
if (svalue [0] < '0' || svalue [0] > '9' || svalue.find_first_of ("@:") != svalue.npos) {
*((double *) data) = (int) Dtime (svalue);
} else {
*((double *) data) = svalue.Double ();
}
break;
case DB_TIME:
*((double *) data) = (double) tvalue;
break;
default:
return (Status (DB_ERROR));
}
break;
case DB_STRING:
switch (fld->Type ()) {
case DB_TIME:
svalue = tvalue.Time_String ();
break;
default:
if (fld_type == DB_INTEGER) {
svalue (lvalue);
} else if (fld_type == DB_DOUBLE) {
svalue (dvalue, fld->Decimal ());
}
break;
}
len = (int) svalue.size ();
if (len > 0) {
if (len > fld->Width ()) len = fld->Width ();
*((string *) data) = svalue.substr (0, len);
} else {
(*((string *) data)).clear ();
}
break;
case DB_TIME:
switch (fld_type) {
case DB_INTEGER:
*((Dtime *) data) = Dtime (lvalue, fld->Units ());
break;
case DB_DOUBLE:
*((Dtime *) data) = Dtime (dvalue, fld->Units ());
break;
case DB_STRING:
*((Dtime *) data) = svalue;
break;
case DB_TIME:
*((Dtime *) data) = tvalue;
break;
default:
return (Status (DB_ERROR));
}
break;
default:
return (Status (DB_ERROR));
}
return (true);
}
bool Db_Base::Output_Record (void)
{
if (File_Format () == SQLITE3) {
int i, j, num, lvalue;
double dvalue;
string svalue;
Db_Field *fld;
num = Num_Fields ();
for (i=0, j=1; i < num; i++) {
fld = Field (i);
if (Nested () != fld->Nested ()) continue;
if (Nested ()) {
if (fld->Type () == DB_INTEGER) {
Get_Field (i, lvalue);
sqlite3_bind_int (insert_nest, j+1, lvalue);
} else if (fld->Type () == DB_DOUBLE) {
Get_Field (i, dvalue);
sqlite3_bind_double (insert_nest, j+1, dvalue);
} else {
Get_Field (i, svalue);
sqlite3_bind_text (insert_nest, j+1, svalue.c_str (), -1, SQLITE_TRANSIENT);
}
} else {
if (fld->Type () == DB_INTEGER) {
Get_Field (i, lvalue);
sqlite3_bind_int (insert_stmt, j, lvalue);
} else if (fld->Type () == DB_DOUBLE) {
Get_Field (i, dvalue);
sqlite3_bind_double (insert_stmt, j, dvalue);
} else {
Get_Field (i, svalue);
sqlite3_bind_text (insert_stmt, j, svalue.c_str (), -1, SQLITE_TRANSIENT);
}
}
j++;
}
if (Nested ()) {
sqlite3_bind_int (insert_nest, 1, parent_id);
if (sqlite3_step (insert_nest) != SQLITE_DONE) {
exe->Warning ("Inserting Database: ") << sqlite3_errmsg (db_file);
}
if (sqlite3_reset (insert_nest) != SQLITE_OK) {
exe->Warning ("Inserting Database: ") << sqlite3_errmsg (db_file);
}
} else {
if (sqlite3_step (insert_stmt) != SQLITE_DONE) {
exe->Warning ("Inserting Database: ") << sqlite3_errmsg (db_file);
}
parent_id = (int) sqlite3_last_insert_rowid (db_file);
if (sqlite3_reset (insert_stmt) != SQLITE_OK) {
exe->Warning ("Inserting Database: ") << sqlite3_errmsg (db_file);
}
}
} else if (File_Format () == CSV_DELIMITED) {
int i, j, max;
string *ptr;
char *delimiter, *record;
bool first = true;
Db_Field *fld;
delimiter = Delimiters ();
record = Record_String ();
for (i=0; i < Num_Fields (); i++) {
fld = Field (i);
if (Nested () == fld->Nested ()) {
ptr = &fld->Buffer ();
max = (int) ptr->size ();
if (max > fld->Width ()) max = fld->Width ();
if (first) {
first = false;
} else {
*record++ = *delimiter;
}
for (j=0; j < max; j++) {
*record++ = (*ptr) [j];
}
*record = '\0';
}
}
Set_Size ();
}
return (true);
}
bool Db_Base::Input_Record (void)
{
if (File_Format () == SQLITE3) {
int i, j, num, lvalue, result;
const unsigned char *text;
double dvalue;
Db_Field *fld;
//---- get the next record ----
if (Nested ()) {
if (new_nest_flag) {
new_nest_flag = false;
sqlite3_reset (read_nest);
sqlite3_bind_int (read_nest, 1, parent_id);
}
result = sqlite3_step (read_nest);
} else {
Record_Number (0);
parent_id = Record_Number ();
new_nest_flag = true;
sqlite3_reset (read_stmt);
sqlite3_bind_int (read_stmt, 1, parent_id);
result = sqlite3_step (read_stmt);
}
if (result == SQLITE_DONE) return (false);
if (result != SQLITE_ROW) {
exe->Warning ("SQLITE3 Read Problem: ") << sqlite3_errmsg (db_file);
}
num = Num_Fields ();
for (i=0, j=0; i < num; i++) {
fld = Field (i);
if (Nested () != fld->Nested ()) continue;
if (Nested ()) {
if (fld->Type () == DB_INTEGER) {
lvalue = sqlite3_column_int (read_nest, j+1);
Put_Field (i, lvalue);
} else if (fld->Type () == DB_DOUBLE) {
dvalue = sqlite3_column_double (read_nest, j+1);
Put_Field (i, dvalue);
} else {
text = sqlite3_column_text (read_nest, j+1);
Put_Field (i, (char *) text);
}
} else {
if (fld->Type () == DB_INTEGER) {
lvalue = sqlite3_column_int (read_stmt, j);
Put_Field (i, lvalue);
} else if (fld->Type () == DB_DOUBLE) {
dvalue = sqlite3_column_double (read_stmt, j);
Put_Field (i, dvalue);
} else {
text = sqlite3_column_text (read_stmt, j);
Put_Field (i, (char *) text);
}
}
j++;
}
} else if (File_Format () == CSV_DELIMITED) {
Strings fields;
Db_Field *fld;
int count = String (Record_String ()).Parse (fields, Delimiters ());
for (int i=0; i < Num_Fields (); i++) {
fld = Field (i);
if (Nested () == fld->Nested ()) {
if (fld->Offset () <= count) {
fld->Buffer (fields [fld->Offset () - 1]);
} else {
fld->Buffer ("");
}
}
}
}
return (true);
}
