The R Project SVN – R-packages – Diff – /trunk/SQLiteDF/src/sqlite_dataframe.c


#include <stdio.h>
#include <string.h>
#include "sqlite_dataframe.h"
 
/****************************************************************************
 * UTILITY FUNCTIONS
 ****************************************************************************/
 
/* if user supplied a name, return that name. otherwise, use the 
 * default "data" */
static int _check_sdf_name(SEXP name, char **rname, char **iname, int *file_idx) {
    int namelen = 0;
 
    /* check if arg name is supplied */
    if (IS_CHARACTER(name)) {
        *rname = CHAR_ELT(name,0);
        if (!_is_r_sym(*rname)) { 
            Rprintf("Error: supplied name \"%s\"is not a valid R symbol.\n", 
                    *rname); 
            return FALSE; 
        }
        namelen = strlen(*rname);
        *iname = (char*)R_alloc(namelen + 9, sizeof(char)); /* <name>10000.db\0 */
        sprintf(*iname, "%s.db", *rname);
    } else if (name == R_NilValue) {
        *rname = "data";
        namelen = 5;
        *iname = (char*)R_alloc(13, sizeof(char)); /* data10000.db\0 */
        *file_idx = 1;
        sprintf(*iname, "%s%d.db", *rname, *file_idx);
    } else {
        Rprintf("Error: the supplied value for arg name is not a string.\n");
    }
    return namelen;
}
 
static int _find_free_filename(char *rname, char **iname, int *namelen, int *file_idx) {
    do {
        if (!_file_exists(*iname)) break;
        *namelen = sprintf(*iname, "%s%d.db", rname, ++(*file_idx)) - 3;
    } while (*file_idx < 10000);
 
    return *file_idx;
}
 
/* creates an sdf attribute table */
static int _create_sdf_attribute2(const char *iname) {
    sprintf(g_sql_buf[2], "create table [%s].sdf_attributes(attr text, "
            "value text, primary key (attr))", iname);
    int res;
    res = _sqlite_exec(g_sql_buf[2]);
    if (res == SQLITE_OK) {
        sprintf(g_sql_buf[2], "insert into [%s].sdf_attributes values ('name',"
                "'%s');", iname, iname);
        res = _sqlite_exec(g_sql_buf[2]);
    }
    return res;
}
 
char *_create_sdf_skeleton2(SEXP name, int *onamelen) {
    char *iname, *rname;
    int namelen, file_idx = 0, res;
 
    namelen = _check_sdf_name(name, &rname, &iname, &file_idx);
 
    if (!namelen) return NULL;
 
    _find_free_filename(rname, &iname, &namelen, &file_idx);
 
    if (file_idx >= 10000) { 
        Rprintf("Error: cannot find free SDF name.\n");
        return NULL;
    }
 
    /* add to workspace */
    strcpy(g_sql_buf[3], iname);
    iname[namelen] = 0; /* remove ".db" */
    res = _add_sdf1(g_sql_buf[3], iname);
    if (_sqlite_error(res)) return NULL;
 
    /* detach SDF's if necessary to attach this one. if file does not
     * exist, then a sqlite db will be created after we make our 1st table */
    if (!USE_SDF(iname)) { _delete_sdf2(iname); return NULL; }
 
 
    /* create attributes table */
    res = _create_sdf_attribute2(iname);
    if (_sqlite_error(res)) {
        sprintf(g_sql_buf[2], "detach '%s'", iname);
        _delete_sdf2(iname);
        return NULL; 
    }
 
    *onamelen = namelen;
    return iname;
}
/* checks if a column has a corresponding factor|ordered table */
static int _is_factor2(const char *iname, const char *factor_type, const char *colname) {
    sqlite3_stmt *stmt;
    sprintf(g_sql_buf[2], "select * from [%s].[%s %s]", iname, factor_type,
            colname);
    int res;
    res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, 0);
    sqlite3_finalize(stmt);
    return res == SQLITE_OK;
}
 
/* create a factor|ordered table */
static int _create_factor_table2(const char *iname, const char *factor_type, 
        const char *colname) {
    sqlite3_stmt *stmt;
    sprintf(g_sql_buf[2], "create table [%s].[%s %s] (level int, label text, "
            "primary key(level), unique(label));", iname, factor_type, colname);
    int res;
    res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, 0);
    if (res == SQLITE_OK) sqlite3_step(stmt);
    sqlite3_finalize(stmt);
    return res; /* error on dup name? */
}
 
/* copy a factor|ordered table from a sdf(db) to another sdf(db) */
static int _copy_factor_levels2(const char *factor_type, const char *iname_src,
        const char *colname_src, const char *iname_dst, const char *colname_dst) {
    sqlite3_stmt *stmt;
    int res;
    res = _create_factor_table2(iname_dst, factor_type, colname_dst);
    if (res == SQLITE_OK) {
        sprintf(g_sql_buf[2], "insert into [%s].[%s %s] select * from [%s].[%s %s]",
                iname_src, factor_type, colname_src, iname_dst, factor_type,
                colname_dst);
        res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, 0);
        if (res == SQLITE_OK) sqlite3_step(stmt);
        sqlite3_finalize(stmt);
    }
    return res; /* error on dup name? */
}
 
 
/* assumes stmt has col_cnt + 1 columns, col 0 is [row name]. returned SEXP is 
 * not UNPROTECT-ed, user will have to do that. will create the names &
 * attach factor infos */
static SEXP _setup_df_sexp1(sqlite3_stmt *stmt, const char *iname, 
        int col_cnt, int row_cnt, int *dup_indices) {
    SEXP ret, names, value, class = R_NilValue;
    int i, type;
    const char *colname, *coltype;
 
    PROTECT(ret = NEW_LIST(col_cnt));
 
    /* set up names. */
    PROTECT(names = NEW_CHARACTER(col_cnt));
    for (i = 0; i < col_cnt; i++) {
        colname = sqlite3_column_name(stmt, i+1);  /* +1 bec [row name is 0] */
        coltype = sqlite3_column_decltype(stmt, i+1);
 
        if (dup_indices[i] == 0) {
            strcpy(g_sql_buf[1], colname);
        } else {
            sprintf(g_sql_buf[1], "%s.%d", colname, dup_indices[i]);
        }
 
        SET_STRING_ELT(names, i, mkChar(g_sql_buf[1]));
 
        if (strcmp(coltype, "text") == 0) {
            PROTECT(value = NEW_CHARACTER(row_cnt));
        } else if (strcmp(coltype, "double") == 0) {
            PROTECT(value = NEW_NUMERIC(row_cnt));
        } else if (strcmp(coltype, "bit") == 0) {
            PROTECT(value = NEW_LOGICAL(row_cnt));
        } else if (strcmp(coltype, "integer") == 0 || 
                   strcmp(coltype, "int") == 0) {
            PROTECT(value = NEW_INTEGER(row_cnt));
            type = _get_factor_levels1(iname, colname, value);
            if (type == VAR_FACTOR) {
                PROTECT(class = mkString("factor"));
                SET_CLASS(value, class);
                UNPROTECT(1);
            } else if (type == VAR_ORDERED) {
                PROTECT(class = NEW_CHARACTER(2));
                SET_STRING_ELT(class, 0, mkChar("ordered"));
                SET_STRING_ELT(class, 1, mkChar("factor"));
                SET_CLASS(value, class);
                UNPROTECT(1);
            }
        } else {
            Rprintf("Error: not supported type %s for %s\n", coltype, colname);
            UNPROTECT(2); /* unprotect ret, names */
            return R_NilValue;
        }
 
        SET_VECTOR_ELT(ret, i, value);
        UNPROTECT(1); /* unprotect value */
                    
    }
    SET_NAMES(ret, names);
    UNPROTECT(1); /* unprotect names only */
    return ret;
}
 
/* expected that 1st col of stmt is [row name], so we start with index 1 */
static int _add_row_to_df(SEXP df, sqlite3_stmt *stmt, int row, int ncols) {
    SEXP vec;
    int type = -1, is_null, i;
    for (i = 1; i <= ncols; i++) {
        vec = VECTOR_ELT(df, i-1);
        type = TYPEOF(vec);
 
        is_null = (sqlite3_column_type(stmt, row) == SQLITE_NULL);
 
        if (type == CHARSXP) {
            SET_STRING_ELT(vec, row, mkChar((char *)sqlite3_column_text(stmt, i)));
        } else if (type == INTSXP) {
            INTEGER(vec)[row] = sqlite3_column_int(stmt, i);
        } else if (type == REALSXP) {
            REAL(vec)[row] = sqlite3_column_double(stmt, i);
        } else if (type == LGLSXP) {
            LOGICAL(vec)[row] = sqlite3_column_int(stmt, i);
        }
    }
    return type;
}
 
static void _set_rownames2(SEXP df) {
    SEXP value = VECTOR_ELT(df, 0);
    int len = LENGTH(value), i;
    PROTECT(value = NEW_CHARACTER(len));
    for (i = 0; i < len; i++) {
        sprintf(g_sql_buf[2], "%d", i+1);
        SET_STRING_ELT(value, i, mkChar(g_sql_buf[2]));
    }
 
    SET_ROWNAMES(df, value);
    UNPROTECT(1);
}
 
 
/****************************************************************************
 * SDF FUNCTIONS
 ****************************************************************************/
 
SEXP sdf_create_sdf(SEXP df, SEXP name) {
    SEXP ret;
    char *iname; 
    int namelen, res, i, j;
 
    /* find free name, attach sdf, create sdf_attributes */
    iname = _create_sdf_skeleton2(name, &namelen);
    
    if (iname != NULL) {
        int sql_len, sql_len2;
        sqlite3_stmt *stmt;
 
        /* create sdf_data table */
        SEXP names = GET_NAMES(df), variable, levels;
        int ncols = GET_LENGTH(names), type, *types;
        char *col_name, *class, *factor;
 
        /* TODO: put constraints on table after inserting everything? */
 
 
        /* 
         * create the create table and insert sql scripts by looping through
         * the columns of df
         */
        types = (int *)R_alloc(ncols, sizeof(int));
        sql_len = sprintf(g_sql_buf[0], "create table [%s].sdf_data ([row name] text", iname);
        sql_len2 = sprintf(g_sql_buf[1], "insert into [%s].sdf_data values(?", iname);
 
        for (i = 0; i < ncols; i++) {
            col_name = CHAR(STRING_ELT(names, i));
 
            /* add column definition to the create table sql */
            _expand_buf(0, sql_len+strlen(col_name)+10);
 
            variable = _getListElement(df, col_name);
            class = CHAR(STRING_ELT(GET_CLASS(variable), 0));
            type = TYPEOF(variable);
            types[i] = type;
 
            sql_len += sprintf(g_sql_buf[0]+sql_len, ", [%s] %s", col_name, 
                    _get_column_type(class, type));
 
            /* add handler to insert table sql */
            _expand_buf(1, sql_len+5);
            strcpy(g_sql_buf[1]+sql_len2, ",?");
            sql_len2 += 2; 
 
            /* create separate table for factors decode */
            if (strcmp(class, "factor") == 0 || strcmp(class, "ordered") == 0){
                if (_create_factor_table2(iname, class, col_name)) 
                    return R_NilValue; /* dup tbl name? */
 
                levels = GET_LEVELS(variable);
                sprintf(g_sql_buf[2], "insert into [%s].[%s %s] values(?, ?);",
                        iname, class, col_name);
                res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, NULL);
                if (_sqlite_error(res)) return R_NilValue; /* dup tbl name? */
 
                for (j = 0; j < GET_LENGTH(levels); j++) {
                    sqlite3_reset(stmt);
                    factor = CHAR(STRING_ELT(levels, j));
                    sqlite3_bind_int(stmt, 1, j+1);
                    sqlite3_bind_text(stmt, 2, factor, -1, SQLITE_STATIC);
                    sqlite3_step(stmt);
                }
                sqlite3_finalize(stmt);
            }
        }
        
        _expand_buf(0,sql_len+35);
        /* sql_len += sprintf(g_sql_buf[0]+sql_len, ", primary key([row name]));");*/
        sql_len += sprintf(g_sql_buf[0]+sql_len, ");");
        res = _sqlite_exec(g_sql_buf[0]);
        if (_sqlite_error(res)) return R_NilValue; /* why? */
 
        /*
         * add the data in df to the sdf
         */
        SEXP rownames = getAttrib(df, R_RowNamesSymbol);
        int nrows = GET_LENGTH(rownames);
        char *row_name;
 
        sprintf(g_sql_buf[1]+sql_len2, ")");
        res = sqlite3_prepare(g_workspace, g_sql_buf[1], -1, &stmt, NULL);
 
        for (i = 0; i < nrows; i++) {
            row_name = CHAR(STRING_ELT(rownames, i));
            sqlite3_reset(stmt);
 
            if (*row_name)
                sqlite3_bind_text(stmt, 1, row_name, strlen(row_name), SQLITE_STATIC);
            else
                sqlite3_bind_int(stmt, 1, i);
 
            for (j = 0; j < ncols; j++) {
                variable = VECTOR_ELT(df, j);
                switch(types[j]) {
                    case INTSXP : 
                        sqlite3_bind_int(stmt, j+2, INTEGER(variable)[i]);
                        break;
                    case REALSXP:
                        sqlite3_bind_double(stmt, j+2, REAL(variable)[i]);
                        break;
                    case CHARSXP:
                        col_name = CHAR(STRING_ELT(variable,i));
                        sqlite3_bind_text(stmt, j+2, col_name, strlen(col_name), SQLITE_STATIC);
                }
                /* TODO: handle NA's & NULL's */
            }
 
            res = sqlite3_step(stmt);
            if (res != SQLITE_DONE) { 
                sqlite3_finalize(stmt);
                Rprintf("ERROR: %s\n", sqlite3_errmsg(g_workspace));
                return R_NilValue; /* why? */
            }
        }
                
        sqlite3_finalize(stmt);
 
 
 
 
 
 
 
 
 
 
 
        /* create a new object representing the sdf */
 
        ret = _create_sdf_sexp(iname);
 
    } else {
        Rprintf("ERROR: unable to create a sqlite data frame.\n");
        ret = R_NilValue;
    }
        
    return ret;
}
 
SEXP sdf_get_names(SEXP sdf) {
    char *iname;
    iname = SDF_INAME(sdf);
    if (!USE_SDF(iname)) return R_NilValue;
 
    int len;
    len = sprintf(g_sql_buf[0], "select * from [%s].sdf_data;", iname);
 
    sqlite3_stmt *stmt;
    int res, i;
   
    res = sqlite3_prepare(g_workspace, g_sql_buf[0], len, &stmt, NULL);
    if (_sqlite_error(res)) return R_NilValue;
 
    SEXP ret;
 
    len = sqlite3_column_count(stmt)-1;
    PROTECT(ret = NEW_CHARACTER(len));
 
    for (i = 0; i < len; i++) {
        SET_STRING_ELT(ret, i, mkChar(sqlite3_column_name(stmt, i+1)));
    }
 
    sqlite3_finalize(stmt);
    UNPROTECT(1);
    return ret;
}
 
SEXP sdf_get_length(SEXP sdf) {
    char *iname;
    iname  = CHAR(STRING_ELT(_getListElement(sdf, "iname"),0));
    if (!USE_SDF(iname)) return R_NilValue;
 
    int len = sprintf(g_sql_buf[0], "select * from [%s].sdf_data;", iname);
 
    sqlite3_stmt *stmt;
    int res;
   
    res = sqlite3_prepare(g_workspace, g_sql_buf[0], len, &stmt, NULL);
    if (_sqlite_error(res)) return R_NilValue;
 
    SEXP ret;
 
    len = sqlite3_column_count(stmt)-1;
    PROTECT(ret = NEW_INTEGER(1));
    INTEGER(ret)[0] = len;
 
    sqlite3_finalize(stmt);
    UNPROTECT(1);
    return ret;
}
 
/* get row count */
SEXP sdf_get_row_count(SEXP sdf) {
    char *iname = CHAR(STRING_ELT(_getListElement(sdf, "iname"),0));
    if (!USE_SDF(iname)) return R_NilValue;
 
    char **out;
    int res, ncol, nrow;
    SEXP ret;
   
    sprintf(g_sql_buf[0], "select count(*) from [%s].sdf_data;", iname);
    res = sqlite3_get_table(g_workspace, g_sql_buf[0], &out, &nrow, &ncol, NULL);
    if (_sqlite_error(res)) return R_NilValue;
 
 
    if (nrow != 1) ret = R_NilValue;
    else {
        PROTECT(ret = NEW_INTEGER(1));
        INTEGER(ret)[0] = atoi(out[1]);
        UNPROTECT(1);
    }
 
    sqlite3_free_table(out);
    return ret;
}
 
    
SEXP sdf_import_table(SEXP _filename, SEXP _name, SEXP _sep, SEXP _quote, 
        SEXP _rownames, SEXP _colnames) {
    char *filename = CHAR_ELT(_filename, 0);
    FILE *f = fopen(filename, "r");
 
    if (f == NULL) {
        Rprintf("Error: File %s does not exist.", filename);
        return R_NilValue;
    }
 
    /*char *sep = CHAR_ELT(_sep, 0), *quote = CHAR_ELT(_quote,0);
    char *name = CHAR_ELT(_name, 0);*/
 
    /* create the table */
    /* insert the stuffs */
    /* register to workspace */
 
    return R_NilValue;
}
 
SEXP sdf_get_index(SEXP sdf, SEXP row, SEXP col) {
    SEXP ret = R_NilValue;
    char *iname = SDF_INAME(sdf);
    if (!USE_SDF(iname)) return R_NilValue;
 
    sqlite3_stmt *stmt;
    int buflen = 0, idxlen, col_cnt, row_cnt, index;
    int i, j,res;
    int *col_indices, col_index_len, *dup_indices;
    int row_index_len = 0;
 
    sprintf(g_sql_buf[0], "select * from [%s].sdf_data ", iname);
    res = sqlite3_prepare(g_workspace, g_sql_buf[0], -1, &stmt, 0);
    if (_sqlite_error(res)) return R_NilValue;
 
    buflen = sprintf(g_sql_buf[0], "select [row name]");
    idxlen = LENGTH(col);
    col_cnt = sqlite3_column_count(stmt) - 1;
 
    /*
     * PROCESS COLUMN INDEX
     */
    if (col == R_NilValue) {
        for (i = 1; i < col_cnt+1; i++) {
            buflen += sprintf(g_sql_buf[0]+buflen, ",[%s]", 
                    sqlite3_column_name(stmt, i)); 
        }
        _expand_buf(0, buflen+20+strlen(iname));
        buflen += sprintf(g_sql_buf[0]+buflen, " from [%s].sdf_data", iname);
        col_index_len = col_cnt;
        col_indices = (int *)R_alloc(idxlen, sizeof(int));
        dup_indices = (int *)R_alloc(idxlen, sizeof(int));
        for (i = 0; i < col_cnt; i++) { col_indices[i] = i; dup_indices[i] = 0; }
    } else if (col == R_NilValue || idxlen < 1) {
        sqlite3_finalize(stmt);
        return R_NilValue;
    } else if (IS_NUMERIC(col)) {
        col_indices = (int *)R_alloc(idxlen, sizeof(int));
        dup_indices = (int *)R_alloc(idxlen, sizeof(int));
        col_index_len = 0;
 
        for (i = 0; i < idxlen; i++) {
            /* no need to correct for 0 base because col 0 is [row name] */
            index = ((int) REAL(col)[i]); 
            if (index > col_cnt) {
                sqlite3_finalize(stmt);
                Rprintf("Error: undefined columns selected\n");
                return R_NilValue;
            } else if (index > 0) {
                buflen += sprintf(g_sql_buf[0]+buflen, ",[%s]", 
                        sqlite3_column_name(stmt,index));
                dup_indices[col_index_len] = 0;
                for (j = 0; j < col_index_len; j++) {
                    if (col_indices[j] == index) dup_indices[col_index_len]++;
                }
                col_indices[col_index_len++] = index;
            } else if (index < 0) {
                sqlite3_finalize(stmt);
                Rprintf("Error: negative indices not supported.\n");
                return R_NilValue;
            }
        }
 
        if (col_index_len == 0) {
            sqlite3_finalize(stmt);
            Rprintf("Error: no indices detected??\n");
            return R_NilValue;
        } else { 
            _expand_buf(0, buflen+20+strlen(iname));
            buflen += sprintf(g_sql_buf[0]+buflen, " from [%s].sdf_data", iname);
        }
    } else if (IS_INTEGER(col)) {
        /* identical logic with IS_NUMERIC, except that we don't have to cast
         * stuffs from SEXP col. the alternative is doing if idxlen times. */
        col_indices = (int *)R_alloc(idxlen, sizeof(int));
        dup_indices = (int *)R_alloc(idxlen, sizeof(int));
        col_index_len = 0;
 
        for (i = 0; i < idxlen; i++) {
            /* no need to correct for 0 base because col 0 is [row name] */
            index = INTEGER(col)[i];
            if (index > col_cnt) {
                sqlite3_finalize(stmt);
                Rprintf("Error: undefined columns selected\n");
                return R_NilValue;
            } else if (index > 0) {
                buflen += sprintf(g_sql_buf[0]+buflen, ",[%s]", 
                        sqlite3_column_name(stmt,index));
                dup_indices[col_index_len] = 0;
                for (j = 0; j < col_index_len; j++) {
                    if (col_indices[j] == index) dup_indices[col_index_len]++;
                }
                col_indices[col_index_len++] = index;
            } else if (index < 0) {
                sqlite3_finalize(stmt);
                Rprintf("Error: negative indices not supported.\n");
                return R_NilValue;
            }
        }
 
        if (col_index_len == 0) {
            sqlite3_finalize(stmt);
            Rprintf("Error: no indices detected??\n");
            return R_NilValue;
        } else { 
            _expand_buf(0, buflen+20+strlen(iname));
            buflen += sprintf(g_sql_buf[0]+buflen, " from [%s].sdf_data", iname);
        }
    } else if (IS_LOGICAL(col)) {
        /* recycling stuff, so max column output is the # of cols in the df */
        col_indices = (int *)R_alloc(col_cnt, sizeof(int));
        dup_indices = (int *)R_alloc(col_cnt, sizeof(int));
        col_index_len = 0;
        for (i = 0; i < col_cnt; i++) {
            if (LOGICAL(col)[i%idxlen]) {
                buflen += sprintf(g_sql_buf[0]+buflen, ",[%s]", 
                        sqlite3_column_name(stmt,i+1));
                dup_indices[col_index_len] = 0;
                col_indices[col_index_len++] = i;
            }
        }
 
        if (col_index_len == 0) {
            sqlite3_finalize(stmt);
            Rprintf("Warning: no column selected.\n");
            return R_NilValue;
        } else { 
            _expand_buf(0, buflen+20+strlen(iname));
            buflen += sprintf(g_sql_buf[0]+buflen, " from [%s].sdf_data", iname);
        }
    } else {
        sqlite3_finalize(stmt);
        Rprintf("Error: don't know how to handle column index.\n");
        return R_NilValue;
    }
 
    /* 
     * PROCESS ROW INDEX
     */
    idxlen = LENGTH(row);
    if (row == R_NilValue) {
        if (col_index_len == 1) {
            ret = sdf_get_variable(sdf, mkString(sqlite3_column_name(stmt,col_indices[0])));
            sqlite3_finalize(stmt);
            return ret;
        } if (col_index_len > 1) {
            /* create a new SDF, logic similar to sdf_create_sdf */
 
            /* find a new name. data<n> ? */
            char *iname2;
            const char *colname;
            int namelen, sql_len, sql_len2;
 
            iname2 = _create_sdf_skeleton2(R_NilValue, &namelen);
 
            /* create sdf_data table */
            sql_len = sprintf(g_sql_buf[1], "create table [%s].sdf_data ([row name] text", iname2);
            sql_len2 = 0;
 
            for (i = 0; i < col_index_len; i++) {
                colname = sqlite3_column_name(stmt, col_indices[i]);
                if (dup_indices[i] == 0) {
                    sql_len += sprintf(g_sql_buf[1]+sql_len, ", [%s] %s", colname,
                            sqlite3_column_decltype(stmt, col_indices[i]));
                } else {
                    /* un-duplicate col names by appending num, just like R */
                    sql_len += sprintf(g_sql_buf[1]+sql_len, ", [%s.%d] %s", colname,
                            dup_indices[i], 
                            sqlite3_column_decltype(stmt, col_indices[i]));
                }
 
                /* deal with possibly factor columns */
                if (_is_factor2(iname, "factor", colname)) {
                    /* found a factor column */
 
                    if (dup_indices[i] == 0)  {
                        _copy_factor_levels2("factor", iname, colname, iname2, colname);
                    } else {
                        sprintf(g_sql_buf[3], "%s.%d", colname, dup_indices[i]);
                        _copy_factor_levels2("factor", iname, colname, iname2, 
                                g_sql_buf[3]);
                    }
                }
 
                /* and deal with ordered factors too... life is hard, then you die */
                if (_is_factor2(iname, "ordered", colname)) {
                    
                    if (dup_indices[i] == 0)  {
                        _copy_factor_levels2("ordered", iname, colname, iname2, 
                                colname);
                    } else {
                        sprintf(g_sql_buf[3], "%s.%d", colname, dup_indices[i]);
                        _copy_factor_levels2("ordered", iname, colname, iname2, 
                                g_sql_buf[3]);
                    }
                }
                                
            }
 
            /* don't need it anymore */
            sqlite3_finalize(stmt);
 
            /* no table index created, that's for v2 I hope*/
            sql_len += sprintf(g_sql_buf[1]+sql_len, ");");
            res = _sqlite_exec(g_sql_buf[1]);
            if (_sqlite_error(res)) { Rprintf("here? %s\n", g_sql_buf[1]); return R_NilValue; }
 
            /* insert data (with row names). buf[0] contains a select */
            sprintf(g_sql_buf[1], "insert into [%s].sdf_data %s", iname2,
                    g_sql_buf[0]);
            res = _sqlite_exec(g_sql_buf[1]);
            if (_sqlite_error(res)) return R_NilValue;
 
            /* add new sdf to workspace */
            sprintf(g_sql_buf[0], "%s.db", iname2);
            res = _add_sdf1(g_sql_buf[0], iname2);
            if (_sqlite_error(res)) return R_NilValue;
 
            /* create SEXP for the SDF */
            ret = _create_sdf_sexp(iname2);
            return ret;
        } else { sqlite3_finalize(stmt); return R_NilValue; }
    } else if (row == R_NilValue || idxlen < 1) {
        sqlite3_finalize(stmt);
        return R_NilValue;
    } else if (IS_NUMERIC(row)) {
        sqlite3_finalize(stmt);
 
        sprintf(g_sql_buf[1], "[%s].sdf_data", iname);
        row_cnt = _get_row_count2(g_sql_buf[1]);
 
        /* append " limit ?,1" to the formed select statement */
        _expand_buf(0, buflen+10);
        buflen += sprintf(g_sql_buf[0]+buflen, " limit ?,1");
        /*Rprintf("sql [%d]: %s\n", buflen, g_sql_buf[0]); */
 
        index = ((int) REAL(row)[0]) - 1;
        if (idxlen < 0 && idxlen == 1) return R_NilValue;
 
        res = sqlite3_prepare(g_workspace, g_sql_buf[0], -1, &stmt, 0);
        if (_sqlite_error(res)) return R_NilValue;
 
        sqlite3_bind_int(stmt, 1, index);
        res = sqlite3_step(stmt);
 
        /* create data frame */
        ret = _setup_df_sexp1(stmt, iname, col_index_len, idxlen, dup_indices);
        if (ret == R_NilValue) { sqlite3_finalize(stmt); return R_NilValue; }
 
        /* put data in it */
        if (index >= 0 && index < row_cnt) {
            _add_row_to_df(ret, stmt, row_index_len++, col_index_len);
        }
 
        for (i = 1; i < idxlen; i++) {
            sqlite3_reset(stmt);
            index = ((int) REAL(row)[i]) - 1;
            if (index >= 0 && index < row_cnt) {
                sqlite3_bind_int(stmt, 1, index);
                res = sqlite3_step(stmt);
                _add_row_to_df(ret, stmt, row_index_len++, col_index_len);
            }
        }
        sqlite3_finalize(stmt);
 
        /* shrink vectors */
        if (row_index_len < idxlen) {
            for (i = 0; i < col_index_len; i++) {
                SET_VECTOR_ELT(ret, i, 
                        _shrink_vector(VECTOR_ELT(ret, i), row_index_len));
            }
        }
 
        UNPROTECT(1); /* for the ret from _setup_df_sexp1 */
    } else if (IS_INTEGER(row)) {
        /* same stuff as with IS_INTEGER, except for setting of var index*/
        sqlite3_finalize(stmt);
 
        sprintf(g_sql_buf[1], "[%s].sdf_data", iname);
        row_cnt = _get_row_count2(g_sql_buf[1]);
 
        /* append " limit ?,1" to the formed select statement */
        _expand_buf(0, buflen+10);
        buflen += sprintf(g_sql_buf[0]+buflen, " limit ?,1");
 
        index = INTEGER(row)[0] - 1;
        if (idxlen < 0 && idxlen == 1) return R_NilValue;
 
        res = sqlite3_prepare(g_workspace, g_sql_buf[0], -1, &stmt, 0);
        if (_sqlite_error(res)) return R_NilValue;
 
        sqlite3_bind_int(stmt, 1, index);
        res = sqlite3_step(stmt);
 
        /* create data frame */
        ret = _setup_df_sexp1(stmt, iname, col_index_len, idxlen, dup_indices);
        if (ret == R_NilValue) { sqlite3_finalize(stmt); return R_NilValue; }
 
        /* put data in it */
        if (index >= 0 && index < row_cnt) {
            _add_row_to_df(ret, stmt, row_index_len++, col_index_len);
        }
 
        for (i = 1; i < idxlen; i++) {
            sqlite3_reset(stmt);
            index = INTEGER(row)[i] - 1;
            if (index >= 0 && index < row_cnt) {
                sqlite3_bind_int(stmt, 1, index);
                res = sqlite3_step(stmt); 
                _add_row_to_df(ret, stmt, row_index_len++, col_index_len);
            }
        }
        sqlite3_finalize(stmt);
 
        /* shrink vectors */
        if (row_index_len < idxlen) {
            for (i = 0; i < col_index_len; i++) {
                SET_VECTOR_ELT(ret, i, 
                        _shrink_vector(VECTOR_ELT(ret, i), row_index_len));
            }
        }
        UNPROTECT(1); /* for the ret from _setup_df_sexp1 */
    } else if (IS_LOGICAL(row)) {
        /* */
        sqlite3_finalize(stmt);
        int est_row_cnt = 0;
 
        sprintf(g_sql_buf[1], "[%s].sdf_data", iname);
        row_cnt = _get_row_count2(g_sql_buf[1]);
 
        /* append " limit ?,1" to the formed select statement */
        _expand_buf(0, buflen+10);
        buflen += sprintf(g_sql_buf[0]+buflen, " limit ?,1");
 
        /* find if there is any TRUE element in the vector */
        for (i = 0; i < idxlen && i < row_cnt; i++) {
            if (LOGICAL(row)[i]) break;
        }
 
        if (i < idxlen && i < row_cnt) {
            est_row_cnt = (idxlen-i) * (row_cnt/idxlen);
            if (row_cnt%idxlen > i) est_row_cnt += (row_cnt%idxlen - i);
 
            res = sqlite3_prepare(g_workspace, g_sql_buf[0], -1, &stmt, 0);
            if (_sqlite_error(res)) return R_NilValue;
 
            sqlite3_bind_int(stmt, 1, i);
            sqlite3_step(stmt);
            ret = _setup_df_sexp1(stmt, iname, col_index_len, est_row_cnt, dup_indices);
            _add_row_to_df(ret, stmt, row_index_len++, col_index_len);
            
            for (i++ ; i < row_cnt; i++) {
                if (LOGICAL(row)[i%idxlen]) {
                    sqlite3_reset(stmt);
                    sqlite3_bind_int(stmt, 1, i);
                    sqlite3_step(stmt);
                    _add_row_to_df(ret, stmt, row_index_len++, col_index_len);
                }
            }
        }
 
        sqlite3_finalize(stmt);
 
        /* shrink vectors */
        if (est_row_cnt > 0 && row_index_len < est_row_cnt) {
            for (i = 0; i < col_index_len; i++) {
                SET_VECTOR_ELT(ret, i, 
                        _shrink_vector(VECTOR_ELT(ret, i), row_index_len));
            }
        }
 
        UNPROTECT(1); /* for the ret from _setup_df_sexp1 */
    }
 
    if (ret != R_NilValue && col_index_len > 1) {
        SEXP class = mkString("data.frame");
        SET_CLASS(ret, class);
        _set_rownames2(ret);
    } else if (ret != R_NilValue && col_index_len == 1) {
        ret = VECTOR_ELT(ret, 0);
    }
 
    return ret;
}
 
 
SEXP sopen(SEXP name) {
    char *filename;
    
    if (IS_CHARACTER(name)) {
        filename = CHAR(STRING_ELT(name,0));
        Rprintf("%s\n", filename);
    }
    /* sqlite3 *db;
    int res = sqlite3_open(filename, &db); */
    SEXP ret;
    PROTECT(ret = NEW_LOGICAL(1));
    LOGICAL(ret)[0] = IS_CHARACTER(name);
    /* sqlite3_close(db); */ 
    UNPROTECT(1);
    return ret;
}

Rev 3307	Rev 3308
1	`#include <stdio.h>`	1	`#include <stdio.h>`
2	`#include <string.h>`	2	`#include <string.h>`
3	`#include "sqlite_dataframe.h"`	3	`#include "sqlite_dataframe.h"`
4		4
5	`/****************************************************************************`	5	`/****************************************************************************`
6	`* UTILITY FUNCTIONS`	6	`* UTILITY FUNCTIONS`
7	`****************************************************************************/`	7	`****************************************************************************/`
8		8
9	`/* if user supplied a name, return that name. otherwise, use the`	9	`/* if user supplied a name, return that name. otherwise, use the`
10	`* default "data" */`	10	`* default "data" */`
11	`static int _check_sdf_name(SEXP name, char rname, char iname, int *file_idx) {`	11	`static int _check_sdf_name(SEXP name, char rname, char iname, int *file_idx) {`
12	`int namelen = 0;`	12	`int namelen = 0;`
13		13
14	`/* check if arg name is supplied */`	14	`/* check if arg name is supplied */`
15	`if (IS_CHARACTER(name)) {`	15	`if (IS_CHARACTER(name)) {`
16	`*rname = CHAR_ELT(name,0);`	16	`*rname = CHAR_ELT(name,0);`
17	`if (!_is_r_sym(*rname)) {`	17	`if (!_is_r_sym(*rname)) {`
18	`Rprintf("Error: supplied name \"%s\"is not a valid R symbol.\n",`	18	`Rprintf("Error: supplied name \"%s\"is not a valid R symbol.\n",`
19	`*rname);`	19	`*rname);`
20	`return FALSE;`	20	`return FALSE;`
21	`}`	21	`}`
22	`namelen = strlen(*rname);`	22	`namelen = strlen(*rname);`
23	`iname = (char)R_alloc(namelen + 9, sizeof(char)); /* <name>10000.db\0 */`	23	`iname = (char)R_alloc(namelen + 9, sizeof(char)); /* <name>10000.db\0 */`
24	`sprintf(iname, "%s.db", rname);`	24	`sprintf(iname, "%s.db", rname);`
25	`} else if (name == R_NilValue) {`	25	`} else if (name == R_NilValue) {`
26	`*rname = "data";`	26	`*rname = "data";`
27	`namelen = 5;`	27	`namelen = 5;`
28	`iname = (char)R_alloc(13, sizeof(char)); /* data10000.db\0 */`	28	`iname = (char)R_alloc(13, sizeof(char)); /* data10000.db\0 */`
29	`*file_idx = 1;`	29	`*file_idx = 1;`
30	`sprintf(iname, "%s%d.db", rname, *file_idx);`	30	`sprintf(iname, "%s%d.db", rname, *file_idx);`
31	`} else {`	31	`} else {`
32	`Rprintf("Error: the supplied value for arg name is not a string.\n");`	32	`Rprintf("Error: the supplied value for arg name is not a string.\n");`
33	`}`	33	`}`
34	`return namelen;`	34	`return namelen;`
35	`}`	35	`}`
36		36
37	`static int _find_free_filename(char rname, char iname, int namelen, int *file_idx) {`	37	`static int _find_free_filename(char rname, char iname, int namelen, int *file_idx) {`
38	`do {`	38	`do {`
39	`if (!_file_exists(*iname)) break;`	39	`if (!_file_exists(*iname)) break;`
40	`namelen = sprintf(iname, "%s%d.db", rname, ++(*file_idx)) - 3;`	40	`namelen = sprintf(iname, "%s%d.db", rname, ++(*file_idx)) - 3;`
41	`} while (*file_idx < 10000);`	41	`} while (*file_idx < 10000);`
42		42
43	`return *file_idx;`	43	`return *file_idx;`
44	`}`	44	`}`
45		45
46	`/* creates an sdf attribute table */`	46	`/* creates an sdf attribute table */`
47	`static int _create_sdf_attribute2(const char *iname) {`	47	`static int _create_sdf_attribute2(const char *iname) {`
48	`sprintf(g_sql_buf[2], "create table [%s].sdf_attributes(attr text, "`	48	`sprintf(g_sql_buf[2], "create table [%s].sdf_attributes(attr text, "`
49	`"value text, primary key (attr))", iname);`	49	`"value text, primary key (attr))", iname);`
50	`int res;`	50	`int res;`
51	`res = _sqlite_exec(g_sql_buf[2]);`	51	`res = _sqlite_exec(g_sql_buf[2]);`
52	`if (res == SQLITE_OK) {`	52	`if (res == SQLITE_OK) {`
53	`sprintf(g_sql_buf[2], "insert into [%s].sdf_attributes values ('name',"`	53	`sprintf(g_sql_buf[2], "insert into [%s].sdf_attributes values ('name',"`
54	`"'%s');", iname, iname);`	54	`"'%s');", iname, iname);`
55	`res = _sqlite_exec(g_sql_buf[2]);`	55	`res = _sqlite_exec(g_sql_buf[2]);`
56	`}`	56	`}`
57	`return res;`	57	`return res;`
58	`}`	58	`}`
59		59
60	`char _create_sdf_skeleton2(SEXP name, int onamelen) {`	60	`char _create_sdf_skeleton2(SEXP name, int onamelen) {`
61	`char iname, rname;`	61	`char iname, rname;`
62	`int namelen, file_idx = 0, res;`	62	`int namelen, file_idx = 0, res;`
63		63
64	`namelen = _check_sdf_name(name, &rname, &iname, &file_idx);`	64	`namelen = _check_sdf_name(name, &rname, &iname, &file_idx);`
65		65
66	`if (!namelen) return NULL;`	66	`if (!namelen) return NULL;`
67		67
68	`_find_free_filename(rname, &iname, &namelen, &file_idx);`	68	`_find_free_filename(rname, &iname, &namelen, &file_idx);`
69		69
70	`if (file_idx >= 10000) {`	70	`if (file_idx >= 10000) {`
71	`Rprintf("Error: cannot find free SDF name.\n");`	71	`Rprintf("Error: cannot find free SDF name.\n");`
72	`return NULL;`	72	`return NULL;`
73	`}`	73	`}`
74		74
75	`/* create new db by attaching a non-existent file */`	75	`/* add to workspace */`
-		76	`strcpy(g_sql_buf[3], iname);`
76	`iname[namelen] = 0; /* remove ".db" */`	77	`iname[namelen] = 0; /* remove ".db" */`
77	`sprintf(g_sql_buf[2], "attach '%s.db' as [%s]", iname, iname);`	78	`res = _add_sdf1(g_sql_buf[3], iname);`
78	`res = _sqlite_exec(g_sql_buf[2]);`	79	`if (_sqlite_error(res)) return NULL;`
-		80
-		81	`/* detach SDF's if necessary to attach this one. if file does not`
-		82	`* exist, then a sqlite db will be created after we make our 1st table */`
79	`if (_sqlite_error(res)) return NULL;`	83	`if (!USE_SDF(iname)) { _delete_sdf2(iname); return NULL; }`
-		84
80		85
81	`/* create attributes table */`	86	`/* create attributes table */`
82	`res = _create_sdf_attribute2(iname);`	87	`res = _create_sdf_attribute2(iname);`
83	`if (_sqlite_error(res)) {`	88	`if (_sqlite_error(res)) {`
84	`sprintf(g_sql_buf[2], "detach '%s'", iname);`	89	`sprintf(g_sql_buf[2], "detach '%s'", iname);`
-		90	`_delete_sdf2(iname);`
85	`return NULL;`	91	`return NULL;`
86	`}`	92	`}`
87		93
88	`*onamelen = namelen;`	94	`*onamelen = namelen;`
89	`return iname;`	95	`return iname;`
90	`}`	96	`}`
91	`/* checks if a column has a corresponding factor\|ordered table */`	97	`/* checks if a column has a corresponding factor\|ordered table */`
92	`static int _is_factor2(const char iname, const char factor_type, const char *colname) {`	98	`static int _is_factor2(const char iname, const char factor_type, const char *colname) {`
93	`sqlite3_stmt *stmt;`	99	`sqlite3_stmt *stmt;`
94	`sprintf(g_sql_buf[2], "select * from [%s].[%s %s]", iname, factor_type,`	100	`sprintf(g_sql_buf[2], "select * from [%s].[%s %s]", iname, factor_type,`
95	`colname);`	101	`colname);`
96	`int res;`	102	`int res;`
97	`res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, 0);`	103	`res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, 0);`
98	`sqlite3_finalize(stmt);`	104	`sqlite3_finalize(stmt);`
99	`return res == SQLITE_OK;`	105	`return res == SQLITE_OK;`
100	`}`	106	`}`
101		107
102	`/* create a factor\|ordered table */`	108	`/* create a factor\|ordered table */`
103	`static int _create_factor_table2(const char iname, const char factor_type,`	109	`static int _create_factor_table2(const char iname, const char factor_type,`
104	`const char *colname) {`	110	`const char *colname) {`
105	`sqlite3_stmt *stmt;`	111	`sqlite3_stmt *stmt;`
106	`sprintf(g_sql_buf[2], "create table [%s].[%s %s] (level int, label text, "`	112	`sprintf(g_sql_buf[2], "create table [%s].[%s %s] (level int, label text, "`
107	`"primary key(level), unique(label));", iname, factor_type, colname);`	113	`"primary key(level), unique(label));", iname, factor_type, colname);`
108	`int res;`	114	`int res;`
109	`res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, 0);`	115	`res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, 0);`
110	`if (res == SQLITE_OK) sqlite3_step(stmt);`	116	`if (res == SQLITE_OK) sqlite3_step(stmt);`
111	`sqlite3_finalize(stmt);`	117	`sqlite3_finalize(stmt);`
112	`return res; /* error on dup name? */`	118	`return res; /* error on dup name? */`
113	`}`	119	`}`
114		120
115	`/* copy a factor\|ordered table from a sdf(db) to another sdf(db) */`	121	`/* copy a factor\|ordered table from a sdf(db) to another sdf(db) */`
116	`static int _copy_factor_levels2(const char factor_type, const char iname_src,`	122	`static int _copy_factor_levels2(const char factor_type, const char iname_src,`
117	`const char colname_src, const char iname_dst, const char *colname_dst) {`	123	`const char colname_src, const char iname_dst, const char *colname_dst) {`
118	`sqlite3_stmt *stmt;`	124	`sqlite3_stmt *stmt;`
119	`int res;`	125	`int res;`
120	`res = _create_factor_table2(iname_dst, factor_type, colname_dst);`	126	`res = _create_factor_table2(iname_dst, factor_type, colname_dst);`
121	`if (res == SQLITE_OK) {`	127	`if (res == SQLITE_OK) {`
122	`sprintf(g_sql_buf[2], "insert into [%s].[%s %s] select * from [%s].[%s %s]",`	128	`sprintf(g_sql_buf[2], "insert into [%s].[%s %s] select * from [%s].[%s %s]",`
123	`iname_src, factor_type, colname_src, iname_dst, factor_type,`	129	`iname_src, factor_type, colname_src, iname_dst, factor_type,`
124	`colname_dst);`	130	`colname_dst);`
125	`res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, 0);`	131	`res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, 0);`
126	`if (res == SQLITE_OK) sqlite3_step(stmt);`	132	`if (res == SQLITE_OK) sqlite3_step(stmt);`
127	`sqlite3_finalize(stmt);`	133	`sqlite3_finalize(stmt);`
128	`}`	134	`}`
129	`return res; /* error on dup name? */`	135	`return res; /* error on dup name? */`
130	`}`	136	`}`
131		137
132		138
133	`/* assumes stmt has col_cnt + 1 columns, col 0 is [row name]. returned SEXP is`	139	`/* assumes stmt has col_cnt + 1 columns, col 0 is [row name]. returned SEXP is`
134	`* not UNPROTECT-ed, user will have to do that. will create the names &`	140	`* not UNPROTECT-ed, user will have to do that. will create the names &`
135	`* attach factor infos */`	141	`* attach factor infos */`
136	`static SEXP _setup_df_sexp1(sqlite3_stmt stmt, const char iname,`	142	`static SEXP _setup_df_sexp1(sqlite3_stmt stmt, const char iname,`
137	`int col_cnt, int row_cnt, int *dup_indices) {`	143	`int col_cnt, int row_cnt, int *dup_indices) {`
138	`SEXP ret, names, value, class = R_NilValue;`	144	`SEXP ret, names, value, class = R_NilValue;`
139	`int i, type;`	145	`int i, type;`
140	`const char colname, coltype;`	146	`const char colname, coltype;`
141		147
142	`PROTECT(ret = NEW_LIST(col_cnt));`	148	`PROTECT(ret = NEW_LIST(col_cnt));`
143		149
144	`/* set up names. */`	150	`/* set up names. */`
145	`PROTECT(names = NEW_CHARACTER(col_cnt));`	151	`PROTECT(names = NEW_CHARACTER(col_cnt));`
146	`for (i = 0; i < col_cnt; i++) {`	152	`for (i = 0; i < col_cnt; i++) {`
147	`colname = sqlite3_column_name(stmt, i+1); /* +1 bec [row name is 0] */`	153	`colname = sqlite3_column_name(stmt, i+1); /* +1 bec [row name is 0] */`
148	`coltype = sqlite3_column_decltype(stmt, i+1);`	154	`coltype = sqlite3_column_decltype(stmt, i+1);`
149		155
150	`if (dup_indices[i] == 0) {`	156	`if (dup_indices[i] == 0) {`
151	`strcpy(g_sql_buf[1], colname);`	157	`strcpy(g_sql_buf[1], colname);`
152	`} else {`	158	`} else {`
153	`sprintf(g_sql_buf[1], "%s.%d", colname, dup_indices[i]);`	159	`sprintf(g_sql_buf[1], "%s.%d", colname, dup_indices[i]);`
154	`}`	160	`}`
155		161
156	`SET_STRING_ELT(names, i, mkChar(g_sql_buf[1]));`	162	`SET_STRING_ELT(names, i, mkChar(g_sql_buf[1]));`
157		163
158	`if (strcmp(coltype, "text") == 0) {`	164	`if (strcmp(coltype, "text") == 0) {`
159	`PROTECT(value = NEW_CHARACTER(row_cnt));`	165	`PROTECT(value = NEW_CHARACTER(row_cnt));`
160	`} else if (strcmp(coltype, "double") == 0) {`	166	`} else if (strcmp(coltype, "double") == 0) {`
161	`PROTECT(value = NEW_NUMERIC(row_cnt));`	167	`PROTECT(value = NEW_NUMERIC(row_cnt));`
162	`} else if (strcmp(coltype, "bit") == 0) {`	168	`} else if (strcmp(coltype, "bit") == 0) {`
163	`PROTECT(value = NEW_LOGICAL(row_cnt));`	169	`PROTECT(value = NEW_LOGICAL(row_cnt));`
164	`} else if (strcmp(coltype, "integer") == 0 \|\|`	170	`} else if (strcmp(coltype, "integer") == 0 \|\|`
165	`strcmp(coltype, "int") == 0) {`	171	`strcmp(coltype, "int") == 0) {`
166	`PROTECT(value = NEW_INTEGER(row_cnt));`	172	`PROTECT(value = NEW_INTEGER(row_cnt));`
167	`type = _get_factor_levels1(iname, colname, value);`	173	`type = _get_factor_levels1(iname, colname, value);`
168	`if (type == VAR_FACTOR) {`	174	`if (type == VAR_FACTOR) {`
169	`PROTECT(class = mkString("factor"));`	175	`PROTECT(class = mkString("factor"));`
170	`SET_CLASS(value, class);`	176	`SET_CLASS(value, class);`
171	`UNPROTECT(1);`	177	`UNPROTECT(1);`
172	`} else if (type == VAR_ORDERED) {`	178	`} else if (type == VAR_ORDERED) {`
173	`PROTECT(class = NEW_CHARACTER(2));`	179	`PROTECT(class = NEW_CHARACTER(2));`
174	`SET_STRING_ELT(class, 0, mkChar("ordered"));`	180	`SET_STRING_ELT(class, 0, mkChar("ordered"));`
175	`SET_STRING_ELT(class, 1, mkChar("factor"));`	181	`SET_STRING_ELT(class, 1, mkChar("factor"));`
176	`SET_CLASS(value, class);`	182	`SET_CLASS(value, class);`
177	`UNPROTECT(1);`	183	`UNPROTECT(1);`
178	`}`	184	`}`
179	`} else {`	185	`} else {`
180	`Rprintf("Error: not supported type %s for %s\n", coltype, colname);`	186	`Rprintf("Error: not supported type %s for %s\n", coltype, colname);`
181	`UNPROTECT(2); /* unprotect ret, names */`	187	`UNPROTECT(2); /* unprotect ret, names */`
182	`return R_NilValue;`	188	`return R_NilValue;`
183	`}`	189	`}`
184		190
185	`SET_VECTOR_ELT(ret, i, value);`	191	`SET_VECTOR_ELT(ret, i, value);`
186	`UNPROTECT(1); /* unprotect value */`	192	`UNPROTECT(1); /* unprotect value */`
187		193
188	`}`	194	`}`
189	`SET_NAMES(ret, names);`	195	`SET_NAMES(ret, names);`
190	`UNPROTECT(1); /* unprotect names only */`	196	`UNPROTECT(1); /* unprotect names only */`
191	`return ret;`	197	`return ret;`
192	`}`	198	`}`
193		199
194	`/* expected that 1st col of stmt is [row name], so we start with index 1 */`	200	`/* expected that 1st col of stmt is [row name], so we start with index 1 */`
195	`static int _add_row_to_df(SEXP df, sqlite3_stmt *stmt, int row, int ncols) {`	201	`static int _add_row_to_df(SEXP df, sqlite3_stmt *stmt, int row, int ncols) {`
196	`SEXP vec;`	202	`SEXP vec;`
197	`int type = -1, is_null, i;`	203	`int type = -1, is_null, i;`
198	`for (i = 1; i <= ncols; i++) {`	204	`for (i = 1; i <= ncols; i++) {`
199	`vec = VECTOR_ELT(df, i-1);`	205	`vec = VECTOR_ELT(df, i-1);`
200	`type = TYPEOF(vec);`	206	`type = TYPEOF(vec);`
201		207
202	`is_null = (sqlite3_column_type(stmt, row) == SQLITE_NULL);`	208	`is_null = (sqlite3_column_type(stmt, row) == SQLITE_NULL);`
203		209
204	`if (type == CHARSXP) {`	210	`if (type == CHARSXP) {`
205	`SET_STRING_ELT(vec, row, mkChar((char *)sqlite3_column_text(stmt, i)));`	211	`SET_STRING_ELT(vec, row, mkChar((char *)sqlite3_column_text(stmt, i)));`
206	`} else if (type == INTSXP) {`	212	`} else if (type == INTSXP) {`
207	`INTEGER(vec)[row] = sqlite3_column_int(stmt, i);`	213	`INTEGER(vec)[row] = sqlite3_column_int(stmt, i);`
208	`} else if (type == REALSXP) {`	214	`} else if (type == REALSXP) {`
209	`REAL(vec)[row] = sqlite3_column_double(stmt, i);`	215	`REAL(vec)[row] = sqlite3_column_double(stmt, i);`
210	`} else if (type == LGLSXP) {`	216	`} else if (type == LGLSXP) {`
211	`LOGICAL(vec)[row] = sqlite3_column_int(stmt, i);`	217	`LOGICAL(vec)[row] = sqlite3_column_int(stmt, i);`
212	`}`	218	`}`
213	`}`	219	`}`
214	`return type;`	220	`return type;`
215	`}`	221	`}`
216		222
217	`static void _set_rownames2(SEXP df) {`	223	`static void _set_rownames2(SEXP df) {`
218	`SEXP value = VECTOR_ELT(df, 0);`	224	`SEXP value = VECTOR_ELT(df, 0);`
219	`int len = LENGTH(value), i;`	225	`int len = LENGTH(value), i;`
220	`PROTECT(value = NEW_CHARACTER(len));`	226	`PROTECT(value = NEW_CHARACTER(len));`
221	`for (i = 0; i < len; i++) {`	227	`for (i = 0; i < len; i++) {`
222	`sprintf(g_sql_buf[2], "%d", i+1);`	228	`sprintf(g_sql_buf[2], "%d", i+1);`
223	`SET_STRING_ELT(value, i, mkChar(g_sql_buf[2]));`	229	`SET_STRING_ELT(value, i, mkChar(g_sql_buf[2]));`
224	`}`	230	`}`
225		231
226	`SET_ROWNAMES(df, value);`	232	`SET_ROWNAMES(df, value);`
227	`UNPROTECT(1);`	233	`UNPROTECT(1);`
228	`}`	234	`}`
229		235
230		236
231	`/****************************************************************************`	237	`/****************************************************************************`
232	`* SDF FUNCTIONS`	238	`* SDF FUNCTIONS`
233	`****************************************************************************/`	239	`****************************************************************************/`
234		240
235	`SEXP sdf_create_sdf(SEXP df, SEXP name) {`	241	`SEXP sdf_create_sdf(SEXP df, SEXP name) {`
236	`SEXP ret;`	242	`SEXP ret;`
237	`char *iname;`	243	`char *iname;`
238	`int namelen, res, i, j;`	244	`int namelen, res, i, j;`
239		245
240	`/* find free name, attach sdf, create sdf_attributes */`	246	`/* find free name, attach sdf, create sdf_attributes */`
241	`iname = _create_sdf_skeleton2(name, &namelen);`	247	`iname = _create_sdf_skeleton2(name, &namelen);`
242		248
243	`if (iname != NULL) {`	249	`if (iname != NULL) {`
244	`int sql_len, sql_len2;`	250	`int sql_len, sql_len2;`
245	`sqlite3_stmt *stmt;`	251	`sqlite3_stmt *stmt;`
246		252
247	`/* create sdf_data table */`	253	`/* create sdf_data table */`
248	`SEXP names = GET_NAMES(df), variable, levels;`	254	`SEXP names = GET_NAMES(df), variable, levels;`
249	`int ncols = GET_LENGTH(names), type, *types;`	255	`int ncols = GET_LENGTH(names), type, *types;`
250	`char col_name, class, *factor;`	256	`char col_name, class, *factor;`
251		257
252	`/* TODO: put constraints on table after inserting everything? */`	258	`/* TODO: put constraints on table after inserting everything? */`
253		259
254		260
255	`/*`	261	`/*`
256	`* create the create table and insert sql scripts by looping through`	262	`* create the create table and insert sql scripts by looping through`
257	`* the columns of df`	263	`* the columns of df`
258	`*/`	264	`*/`
259	`types = (int *)R_alloc(ncols, sizeof(int));`	265	`types = (int *)R_alloc(ncols, sizeof(int));`
260	`sql_len = sprintf(g_sql_buf[0], "create table [%s].sdf_data ([row name] text", iname);`	266	`sql_len = sprintf(g_sql_buf[0], "create table [%s].sdf_data ([row name] text", iname);`
261	`sql_len2 = sprintf(g_sql_buf[1], "insert into [%s].sdf_data values(?", iname);`	267	`sql_len2 = sprintf(g_sql_buf[1], "insert into [%s].sdf_data values(?", iname);`
262		268
263	`for (i = 0; i < ncols; i++) {`	269	`for (i = 0; i < ncols; i++) {`
264	`col_name = CHAR(STRING_ELT(names, i));`	270	`col_name = CHAR(STRING_ELT(names, i));`
265		271
266	`/* add column definition to the create table sql */`	272	`/* add column definition to the create table sql */`
267	`_expand_buf(0, sql_len+strlen(col_name)+10);`	273	`_expand_buf(0, sql_len+strlen(col_name)+10);`
268		274
269	`variable = _getListElement(df, col_name);`	275	`variable = _getListElement(df, col_name);`
270	`class = CHAR(STRING_ELT(GET_CLASS(variable), 0));`	276	`class = CHAR(STRING_ELT(GET_CLASS(variable), 0));`
271	`type = TYPEOF(variable);`	277	`type = TYPEOF(variable);`
272	`types[i] = type;`	278	`types[i] = type;`
273		279
274	`sql_len += sprintf(g_sql_buf[0]+sql_len, ", [%s] %s", col_name,`	280	`sql_len += sprintf(g_sql_buf[0]+sql_len, ", [%s] %s", col_name,`
275	`_get_column_type(class, type));`	281	`_get_column_type(class, type));`
276		282
277	`/* add handler to insert table sql */`	283	`/* add handler to insert table sql */`
278	`_expand_buf(1, sql_len+5);`	284	`_expand_buf(1, sql_len+5);`
279	`strcpy(g_sql_buf[1]+sql_len2, ",?");`	285	`strcpy(g_sql_buf[1]+sql_len2, ",?");`
280	`sql_len2 += 2;`	286	`sql_len2 += 2;`
281		287
282	`/* create separate table for factors decode */`	288	`/* create separate table for factors decode */`
283	`if (strcmp(class, "factor") == 0 \|\| strcmp(class, "ordered") == 0){`	289	`if (strcmp(class, "factor") == 0 \|\| strcmp(class, "ordered") == 0){`
284	`if (_create_factor_table2(iname, class, col_name))`	290	`if (_create_factor_table2(iname, class, col_name))`
285	`return R_NilValue; /* dup tbl name? */`	291	`return R_NilValue; /* dup tbl name? */`
286		292
287	`levels = GET_LEVELS(variable);`	293	`levels = GET_LEVELS(variable);`
288	`sprintf(g_sql_buf[2], "insert into [%s].[%s %s] values(?, ?);",`	294	`sprintf(g_sql_buf[2], "insert into [%s].[%s %s] values(?, ?);",`
289	`iname, class, col_name);`	295	`iname, class, col_name);`
290	`res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, NULL);`	296	`res = sqlite3_prepare(g_workspace, g_sql_buf[2], -1, &stmt, NULL);`
291	`if (_sqlite_error(res)) return R_NilValue; /* dup tbl name? */`	297	`if (_sqlite_error(res)) return R_NilValue; /* dup tbl name? */`
292		298
293	`for (j = 0; j < GET_LENGTH(levels); j++) {`	299	`for (j = 0; j < GET_LENGTH(levels); j++) {`
294	`sqlite3_reset(stmt);`	300	`sqlite3_reset(stmt);`
295	`factor = CHAR(STRING_ELT(levels, j));`	301	`factor = CHAR(STRING_ELT(levels, j));`
296	`sqlite3_bind_int(stmt, 1, j+1);`	302	`sqlite3_bind_int(stmt, 1, j+1);`
297	`sqlite3_bind_text(stmt, 2, factor, -1, SQLITE_STATIC);`	303	`sqlite3_bind_text(stmt, 2, factor, -1, SQLITE_STATIC);`
298	`sqlite3_step(stmt);`	304	`sqlite3_step(stmt);`
299	`}`	305	`}`
300	`sqlite3_finalize(stmt);`	306	`sqlite3_finalize(stmt);`
301	`}`	307	`}`
302	`}`	308	`}`
303		309
304	`_expand_buf(0,sql_len+35);`	310	`_expand_buf(0,sql_len+35);`
305	`/* sql_len += sprintf(g_sql_buf[0]+sql_len, ", primary key([row name]));");*/`	311	`/* sql_len += sprintf(g_sql_buf[0]+sql_len, ", primary key([row name]));");*/`
306	`sql_len += sprintf(g_sql_buf[0]+sql_len, ");");`	312	`sql_len += sprintf(g_sql_buf[0]+sql_len, ");");`
307	`res = _sqlite_exec(g_sql_buf[0]);`	313	`res = _sqlite_exec(g_sql_buf[0]);`
308	`if (_sqlite_error(res)) return R_NilValue; /* why? */`	314	`if (_sqlite_error(res)) return R_NilValue; /* why? */`
309		315
310	`/*`	316	`/*`
311	`* add the data in df to the sdf`	317	`* add the data in df to the sdf`
312	`*/`	318	`*/`
313	`SEXP rownames = getAttrib(df, R_RowNamesSymbol);`	319	`SEXP rownames = getAttrib(df, R_RowNamesSymbol);`
314	`int nrows = GET_LENGTH(rownames);`	320	`int nrows = GET_LENGTH(rownames);`
315	`char *row_name;`	321	`char *row_name;`
316		322
317	`sprintf(g_sql_buf[1]+sql_len2, ")");`	323	`sprintf(g_sql_buf[1]+sql_len2, ")");`
318	`res = sqlite3_prepare(g_workspace, g_sql_buf[1], -1, &stmt, NULL);`	324	`res = sqlite3_prepare(g_workspace, g_sql_buf[1], -1, &stmt, NULL);`
319		325
320	`for (i = 0; i < nrows; i++) {`	326	`for (i = 0; i < nrows; i++) {`
321	`row_name = CHAR(STRING_ELT(rownames, i));`	327	`row_name = CHAR(STRING_ELT(rownames, i));`
322	`sqlite3_reset(stmt);`	328	`sqlite3_reset(stmt);`
323		329
324	`if (*row_name)`	330	`if (*row_name)`
325	`sqlite3_bind_text(stmt, 1, row_name, strlen(row_name), SQLITE_STATIC);`	331	`sqlite3_bind_text(stmt, 1, row_name, strlen(row_name), SQLITE_STATIC);`
326	`else`	332	`else`
327	`sqlite3_bind_int(stmt, 1, i);`	333	`sqlite3_bind_int(stmt, 1, i);`
328		334
329	`for (j = 0; j < ncols; j++) {`	335	`for (j = 0; j < ncols; j++) {`
330	`variable = VECTOR_ELT(df, j);`	336	`variable = VECTOR_ELT(df, j);`
331	`switch(types[j]) {`	337	`switch(types[j]) {`
332	`case INTSXP :`	338	`case INTSXP :`
333	`sqlite3_bind_int(stmt, j+2, INTEGER(variable)[i]);`	339	`sqlite3_bind_int(stmt, j+2, INTEGER(variable)[i]);`
334	`break;`	340	`break;`
335	`case REALSXP:`	341	`case REALSXP:`
336	`sqlite3_bind_double(stmt, j+2, REAL(variable)[i]);`	342	`sqlite3_bind_double(stmt, j+2, REAL(variable)[i]);`
337	`break;`	343	`break;`
338	`case CHARSXP:`	344	`case CHARSXP:`
339	`col_name = CHAR(STRING_ELT(variable,i));`	345	`col_name = CHAR(STRING_ELT(variable,i));`
340	`sqlite3_bind_text(stmt, j+2, col_name, strlen(col_name), SQLITE_STATIC);`	346	`sqlite3_bind_text(stmt, j+2, col_name, strlen(col_name), SQLITE_STATIC);`
341	`}`	347	`}`
342	`/* TODO: handle NA's & NULL's */`	348	`/* TODO: handle NA's & NULL's */`
343	`}`	349	`}`
344		350
345	`res = sqlite3_step(stmt);`	351	`res = sqlite3_step(stmt);`
346	`if (res != SQLITE_DONE) {`	352	`if (res != SQLITE_DONE) {`
347	`sqlite3_finalize(stmt);`	353	`sqlite3_finalize(stmt);`
348	`Rprintf("ERROR: %s\n", sqlite3_errmsg(g_workspace));`	354	`Rprintf("ERROR: %s\n", sqlite3_errmsg(g_workspace));`
349	`return R_NilValue; /* why? */`	355	`return R_NilValue; /* why? */`
350	`}`	356	`}`
351	`}`	357	`}`
352		358
353	`sqlite3_finalize(stmt);`	359	`sqlite3_finalize(stmt);`
354		360
355	`/*`	-
356	`* add the new sdf to the workspace`	-
357	`*/`	-
358	`iname[namelen] = '.';`	-
359	`strcpy(g_sql_buf[0], iname);`	-
360	`iname[namelen] = 0;`	-
361	`res = _add_sdf1(g_sql_buf[0], iname);`	-
362	`if (_sqlite_error(res)) return R_NilValue; /* why? */`	-
363		-
364	`/*`	-
365	`* create a new object representing the sdf`	361	`/* create a new object representing the sdf */`
366	`*/`	-
367	`ret = _create_sdf_sexp(iname);`	362	`ret = _create_sdf_sexp(iname);`
368		363
369	`} else {`	364	`} else {`
370	`Rprintf("ERROR: cannot find a free internal name.");`	365	`Rprintf("ERROR: unable to create a sqlite data frame.\n");`
371	`ret = R_NilValue;`	366	`ret = R_NilValue;`
372	`}`	367	`}`
373		368
374	`return ret;`	369	`return ret;`
375	`}`	370	`}`
376		371
377	`SEXP sdf_get_names(SEXP sdf) {`	372	`SEXP sdf_get_names(SEXP sdf) {`
-		373	`char *iname;`
378	`char *iname = SDF_INAME(sdf);`	374	`iname = SDF_INAME(sdf);`
-		375	`if (!USE_SDF(iname)) return R_NilValue;`
-		376
-		377	`int len;`
379	`int len = sprintf(g_sql_buf[0], "select * from [%s].sdf_data;", iname);`	378	`len = sprintf(g_sql_buf[0], "select * from [%s].sdf_data;", iname);`
380		379
381	`sqlite3_stmt *stmt;`	380	`sqlite3_stmt *stmt;`
382	`int res, i;`	381	`int res, i;`
383		382
384	`res = sqlite3_prepare(g_workspace, g_sql_buf[0], len, &stmt, NULL);`	383	`res = sqlite3_prepare(g_workspace, g_sql_buf[0], len, &stmt, NULL);`
385	`if (_sqlite_error(res)) return R_NilValue;`	384	`if (_sqlite_error(res)) return R_NilValue;`
386		385
387	`SEXP ret;`	386	`SEXP ret;`
388		387
389	`len = sqlite3_column_count(stmt)-1;`	388	`len = sqlite3_column_count(stmt)-1;`
390	`PROTECT(ret = NEW_CHARACTER(len));`	389	`PROTECT(ret = NEW_CHARACTER(len));`
391		390
392	`for (i = 0; i < len; i++) {`	391	`for (i = 0; i < len; i++) {`
393	`SET_STRING_ELT(ret, i, mkChar(sqlite3_column_name(stmt, i+1)));`	392	`SET_STRING_ELT(ret, i, mkChar(sqlite3_column_name(stmt, i+1)));`
394	`}`	393	`}`
395		394
396	`sqlite3_finalize(stmt);`	395	`sqlite3_finalize(stmt);`
397	`UNPROTECT(1);`	396	`UNPROTECT(1);`
398	`return ret;`	397	`return ret;`
399	`}`	398	`}`
400		399
401	`SEXP sdf_get_length(SEXP sdf) {`	400	`SEXP sdf_get_length(SEXP sdf) {`
-		401	`char *iname;`
402	`char *iname = CHAR(STRING_ELT(_getListElement(sdf, "iname"),0));`	402	`iname = CHAR(STRING_ELT(_getListElement(sdf, "iname"),0));`
-		403	`if (!USE_SDF(iname)) return R_NilValue;`
-		404
403	`int len = sprintf(g_sql_buf[0], "select * from [%s].sdf_data;", iname);`	405	`int len = sprintf(g_sql_buf[0], "select * from [%s].sdf_data;", iname);`
404		406
405	`sqlite3_stmt *stmt;`	407	`sqlite3_stmt *stmt;`
406	`int res;`	408	`int res;`
407		409
408	`res = sqlite3_prepare(g_workspace, g_sql_buf[0], len, &stmt, NULL);`	410	`res = sqlite3_prepare(g_workspace, g_sql_buf[0], len, &stmt, NULL);`
409	`if (_sqlite_error(res)) return R_NilValue;`	411	`if (_sqlite_error(res)) return R_NilValue;`
410		412
411	`SEXP ret;`	413	`SEXP ret;`
412		414
413	`len = sqlite3_column_count(stmt)-1;`	415	`len = sqlite3_column_count(stmt)-1;`
414	`PROTECT(ret = NEW_INTEGER(1));`	416	`PROTECT(ret = NEW_INTEGER(1));`
415	`INTEGER(ret)[0] = len;`	417	`INTEGER(ret)[0] = len;`
416		418
417	`sqlite3_finalize(stmt);`	419	`sqlite3_finalize(stmt);`
418	`UNPROTECT(1);`	420	`UNPROTECT(1);`
419	`return ret;`	421	`return ret;`
420	`}`	422	`}`
421		423
422	`/* get row count */`	424	`/* get row count */`
423	`SEXP sdf_get_row_count(SEXP sdf) {`	425	`SEXP sdf_get_row_count(SEXP sdf) {`
424	`char *iname = CHAR(STRING_ELT(_getListElement(sdf, "iname"),0));`	426	`char *iname = CHAR(STRING_ELT(_getListElement(sdf, "iname"),0));`
-		427	`if (!USE_SDF(iname)) return R_NilValue;`
-		428
425	`char **out;`	429	`char **out;`
426	`int res, ncol, nrow;`	430	`int res, ncol, nrow;`
427	`SEXP ret;`	431	`SEXP ret;`
428		432
429	`sprintf(g_sql_buf[0], "select count(*) from [%s].sdf_data;", iname);`	433	`sprintf(g_sql_buf[0], "select count(*) from [%s].sdf_data;", iname);`
430	`res = sqlite3_get_table(g_workspace, g_sql_buf[0], &out, &nrow, &ncol, NULL);`	434	`res = sqlite3_get_table(g_workspace, g_sql_buf[0], &out, &nrow, &ncol, NULL);`
431	`if (_sqlite_error(res)) return R_NilValue;`	435	`if (_sqlite_error(res)) return R_NilValue;`
432		436
433		437
434	`if (nrow != 1) ret = R_NilValue;`	438	`if (nrow != 1) ret = R_NilValue;`
435	`else {`	439	`else {`
436	`PROTECT(ret = NEW_INTEGER(1));`	440	`PROTECT(ret = NEW_INTEGER(1));`
437	`INTEGER(ret)[0] = atoi(out[1]);`	441	`INTEGER(ret)[0] = atoi(out[1]);`
438	`UNPROTECT(1);`	442	`UNPROTECT(1);`
439	`}`	443	`}`
440		444
441	`sqlite3_free_table(out);`	445	`sqlite3_free_table(out);`
442	`return ret;`	446	`return ret;`
443	`}`	447	`}`
444		448
445		449
446	`SEXP sdf_import_table(SEXP _filename, SEXP _name, SEXP _sep, SEXP _quote,`	450	`SEXP sdf_import_table(SEXP _filename, SEXP _name, SEXP _sep, SEXP _quote,`
447	`SEXP _rownames, SEXP _colnames) {`	451	`SEXP _rownames, SEXP _colnames) {`
448	`char *filename = CHAR_ELT(_filename, 0);`	452	`char *filename = CHAR_ELT(_filename, 0);`
449	`FILE *f = fopen(filename, "r");`	453	`FILE *f = fopen(filename, "r");`
450		454
451	`if (f == NULL) {`	455	`if (f == NULL) {`
452	`Rprintf("Error: File %s does not exist.", filename);`	456	`Rprintf("Error: File %s does not exist.", filename);`
453	`return R_NilValue;`	457	`return R_NilValue;`
454	`}`	458	`}`
455		459
456	`/char sep = CHAR_ELT(_sep, 0), *quote = CHAR_ELT(_quote,0);`	460	`/char sep = CHAR_ELT(_sep, 0), *quote = CHAR_ELT(_quote,0);`
457	`char name = CHAR_ELT(_name, 0);/`	461	`char name = CHAR_ELT(_name, 0);/`
458		462
459	`/* create the table */`	463	`/* create the table */`
460	`/* insert the stuffs */`	464	`/* insert the stuffs */`
461	`/* register to workspace */`	465	`/* register to workspace */`
462		466
463	`return R_NilValue;`	467	`return R_NilValue;`
464	`}`	468	`}`
465		469
466	`SEXP sdf_get_index(SEXP sdf, SEXP row, SEXP col) {`	470	`SEXP sdf_get_index(SEXP sdf, SEXP row, SEXP col) {`
467	`SEXP ret = R_NilValue;`	471	`SEXP ret = R_NilValue;`
468	`char *iname = SDF_INAME(sdf);`	472	`char *iname = SDF_INAME(sdf);`
-		473	`if (!USE_SDF(iname)) return R_NilValue;`
-		474
469	`sqlite3_stmt *stmt;`	475	`sqlite3_stmt *stmt;`
470	`int buflen = 0, idxlen, col_cnt, row_cnt, index;`	476	`int buflen = 0, idxlen, col_cnt, row_cnt, index;`
471	`int i, j,res;`	477	`int i, j,res;`
472	`int col_indices, col_index_len, dup_indices;`	478	`int col_indices, col_index_len, dup_indices;`
473	`int row_index_len = 0;`	479	`int row_index_len = 0;`
474		480
475	`sprintf(g_sql_buf[0], "select * from [%s].sdf_data ", iname);`	481	`sprintf(g_sql_buf[0], "select * from [%s].sdf_data ", iname);`
476	`res = sqlite3_prepare(g_workspace, g_sql_buf[0], -1, &stmt, 0);`	482	`res = sqlite3_prepare(g_workspace, g_sql_buf[0], -1, &stmt, 0);`
477	`if (_sqlite_error(res)) return R_NilValue;`	483	`if (_sqlite_error(res)) return R_NilValue;`
478		484
479	`buflen = sprintf(g_sql_buf[0], "select [row name]");`	485	`buflen = sprintf(g_sql_buf[0], "select [row name]");`
480	`idxlen = LENGTH(col);`	486	`idxlen = LENGTH(col);`
481	`col_cnt = sqlite3_column_count(stmt) - 1;`	487	`col_cnt = sqlite3_column_count(stmt) - 1;`
482		488
483	`/*`	489	`/*`

The R Project SVN R-packages

(root)/trunk/SQLiteDF/src/sqlite_dataframe.c – Rev 3307 → 3308