jnicli.cpp

FastDb是高效的内存数据库系统

    dbDatabaseThreadContext* getThreadContext() { 
        return threadContext.get();
    }
    
    void setThreadContext(dbDatabaseThreadContext* ctx) { 
        threadContext.set(ctx);
    }
            
    ClassDescriptor* createTableDescriptor(JNIEnv* env, jstring table, jobjectArray fields, jintArray types, jobjectArray referencedTables, jobjectArray inverseFields, jintArray constraintMasks)
    {
        int i;
        size_t totalNameLength = 0;
        int nFields = env->GetArrayLength(fields);
        cli_field_descriptor* columns = new cli_field_descriptor[nFields];
        for (i = 0; i < nFields; i++) { 
            jstring referencedTable = (jstring)env->GetObjectArrayElement(referencedTables, i);
            if (referencedTable != NULL) {                 
                totalNameLength += getStringLength(env, referencedTable) + 1;
                jstring inverseField = (jstring)env->GetObjectArrayElement(inverseFields, i);
                if (inverseField != NULL) {                 
                    totalNameLength += getStringLength(env, inverseField) + 1;
                }
            }
            totalNameLength += getStringLength(env, (jstring)env->GetObjectArrayElement(fields, i)) + 1;
        }
        char* names = new char[totalNameLength];
        char* np = names;
        jint* jniTypes = env->GetIntArrayElements(types, 0);
        jint* flags = env->GetIntArrayElements(constraintMasks, 0);

        for (i = 0; i < nFields; i++) { 
            jstring referencedTable = (jstring)env->GetObjectArrayElement(referencedTables, i);
            columns[i].flags = flags[i];
            columns[i].refTableName = NULL;
            columns[i].inverseRefFieldName = NULL;
            cli_var_type cliType = cliTypeMap[jniTypes[i]];
            if (referencedTable != NULL) {
                switch (cliType) {
                  case cli_int4:
                  case cli_int8:
                    cliType = cli_oid;
                    break;
                  case cli_array_of_int4:
                  case cli_array_of_int8:
                    cliType = cli_array_of_oid;
                    break;
                  default:
                    handleError(dbDatabase::DatabaseOpenError, "Reference field should have int or long type");
                }                    
                columns[i].refTableName = np;
                int len = getStringLength(env, referencedTable);
                char const* body = getStringBody(env, referencedTable);
                memcpy(np, body, len);
                np[len] = 0;
                releaseStringBody(env, referencedTable, body);
                np += len+1;

                jstring inverseField = (jstring)env->GetObjectArrayElement(inverseFields, i);
                if (inverseField != NULL) {                 
                    columns[i].inverseRefFieldName = np;
                    int len = getStringLength(env, inverseField);
                    char const* body = getStringBody(env, inverseField);
                    memcpy(np, body, len);
                    np[len] = 0;
                    releaseStringBody(env, inverseField, body);
                    np += len+1;
                }                    
            } else if (columns[i].flags & AUTOINCREMENT) { 
                cliType = cli_autoincrement;
            }
            columns[i].type = cliType;
            columns[i].name = np;
            jstring fieldName = (jstring)env->GetObjectArrayElement(fields, i);
            int len = getStringLength(env, fieldName);
            char const* body = getStringBody(env, fieldName);
            memcpy(np, body, len);
            np[len] = 0;
            releaseStringBody(env, fieldName, body);
            np += len+1;
        }
        env->ReleaseIntArrayElements(constraintMasks, flags, 0);
        env->ReleaseIntArrayElements(types, jniTypes, 0);
        ClassDescriptor* desc = new ClassDescriptor();
        desc->columns = columns;
        desc->names = names;
        desc->nColumns = nFields;
        char const* body = getStringBody(env, table);
        releaseStringBody(env, table, body);
        return desc;
    }
};

    

jlong JNICALL   jniOpen(JNIEnv* env, jclass, jint accessType, jstring databaseName, jstring databasePath, jlong initSize, jint transactionCommitDelay)
{
    JniDatabase* db = new JniDatabase(env,
                                      (dbDatabase::dbAccessType)accessType, 
                                      (size_t)initSize);
    char const* name = getStringBody(env, databaseName);
    char const* path = getStringBody(env, databasePath);
    db->open(name, path, transactionCommitDelay);
    releaseStringBody(env, databaseName, name);
    releaseStringBody(env, databasePath, path);
    return (jlong)db;
}
        
void JNICALL   jniClose(JNIEnv* env, jclass, jlong db)
{
    JniDatabase* jdb = (JniDatabase*)db;
    jdb->close();
    delete jdb;
    dbTableDescriptor::cleanup();
}

jstring JNICALL jniNextTable(JNIEnv* env, jclass, jlong db)
{
    return ((JniDatabase*)db)->nextTable();
}

jlong JNICALL   jniUpdateTable(JNIEnv* env, jclass, jlong db, jstring table, jlong desc)
{
    char const* name = getStringBody(env, table);
    dbTableDescriptor* td = ((JniDatabase*)db)->updateTable(name, (ClassDescriptor*)desc);
    releaseStringBody(env, table, name);
    return (jlong)td;
}


jlong JNICALL   jniCreateBuffer(JNIEnv* env, jclass)
{
    return (jlong)new ObjectBuffer();
}

void JNICALL   jniSetByte(JNIEnv* env, jclass, jlong bptr, jbyte v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    *(jbyte*)buf->appendFixed(sizeof(jbyte)) = v;
}
    
void JNICALL   jniSetShort(JNIEnv* env, jclass, jlong bptr, jshort v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    *(jshort*)buf->appendFixed(sizeof(jshort)) = v;
}

void JNICALL   jniSetInt(JNIEnv* env, jclass, jlong bptr, jint v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    *(jint*)buf->appendFixed(sizeof(jint)) = v;
}

void JNICALL   jniSetLong(JNIEnv* env, jclass, jlong bptr, jlong v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    *(jlong*)buf->appendFixed(sizeof(jlong)) = v;
}

void JNICALL   jniSetString(JNIEnv* env, jclass, jlong bptr, jstring v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    if (v == NULL) { 
        *(char const**)buf->appendFixed(sizeof(char*)) = "";
    } else { 
        char const* s = getStringBody(env, v);
        size_t len = getStringLength(env, v);
        char* str = (char*)buf->appendVarying(len+1, sizeof(char));
        memcpy(str, s, len);    
        str[len] = 0;
        *(char**)buf->appendFixed(sizeof(char*)) = str;
        releaseStringBody(env, v, s);
    }
}

void JNICALL   jniSetBoolArray(JNIEnv* env, jclass, jlong bptr, jbooleanArray v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    jboolean* booleans = env->GetBooleanArrayElements(v, 0);
    size_t len = env->GetArrayLength(v);
    char* elems = (char*)buf->appendVarying(len, 1);
    memcpy(elems, booleans, len);    
    cli_array_t* arr = (cli_array_t*)buf->appendFixed(sizeof(cli_array_t), sizeof(void*));
    arr->size = len;
    arr->data = elems;
    arr->allocated = 0;
    env->ReleaseBooleanArrayElements(v, booleans, 0);
}

void JNICALL   jniSetCharArray(JNIEnv* env, jclass, jlong bptr, jcharArray v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    jchar* chars = env->GetCharArrayElements(v, 0);
    size_t len = env->GetArrayLength(v);
    jchar* elems = (jchar*)buf->appendVarying(len, sizeof(jchar));
    memcpy(elems, chars, len*sizeof(jchar));    
    cli_array_t* arr = (cli_array_t*)buf->appendFixed(sizeof(cli_array_t), sizeof(void*));
    arr->size = len;
    arr->data = elems;
    arr->allocated = 0;
    env->ReleaseCharArrayElements(v, chars, 0);
}

void JNICALL   jniSetByteArray(JNIEnv* env, jclass, jlong bptr, jbyteArray v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    jbyte* bytes = env->GetByteArrayElements(v, 0);
    size_t len = env->GetArrayLength(v);
    char* elems = (char*)buf->appendVarying(len, 1);
    memcpy(elems, bytes, len);    
    cli_array_t* arr = (cli_array_t*)buf->appendFixed(sizeof(cli_array_t), sizeof(void*));
    arr->size = len;
    arr->data = elems;
    arr->allocated = 0;
    env->ReleaseByteArrayElements(v, bytes, 0);
}

void JNICALL   jniSetShortArray(JNIEnv* env, jclass, jlong bptr, jshortArray v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    jshort* shorts = env->GetShortArrayElements(v, 0);
    size_t len = env->GetArrayLength(v);
    short* elems = (short*)buf->appendVarying(len, sizeof(short));
    memcpy(elems, shorts, len*sizeof(short));    
    cli_array_t* arr = (cli_array_t*)buf->appendFixed(sizeof(cli_array_t), sizeof(void*));
    arr->size = len;
    arr->data = elems;
    arr->allocated = 0;
    env->ReleaseShortArrayElements(v, shorts, 0);
}

void JNICALL   jniSetIntArray(JNIEnv* env, jclass, jlong bptr, jintArray v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    jint* ints = env->GetIntArrayElements(v, 0);
    size_t len = env->GetArrayLength(v);
    int* elems = (int*)buf->appendVarying(len, sizeof(int));
    memcpy(elems, ints, len*sizeof(int));    
    cli_array_t* arr = (cli_array_t*)buf->appendFixed(sizeof(cli_array_t), sizeof(void*));
    arr->size = len;
    arr->data = elems;
    arr->allocated = 0;
    env->ReleaseIntArrayElements(v, ints, 0);
}

void JNICALL   jniSetLongArray(JNIEnv* env, jclass, jlong bptr, jlongArray v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    jlong* longs = env->GetLongArrayElements(v, 0);
    size_t len = env->GetArrayLength(v);
    jlong* elems = (jlong*)buf->appendVarying(len, sizeof(jlong));
    memcpy(elems, longs, len*sizeof(jlong));    
    cli_array_t* arr = (cli_array_t*)buf->appendFixed(sizeof(cli_array_t), sizeof(void*));
    arr->size = len;
    arr->data = elems;
    arr->allocated = 0;
    env->ReleaseLongArrayElements(v, longs, 0);
}

void JNICALL   jniSetFloatArray(JNIEnv* env, jclass, jlong bptr, jfloatArray v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    jfloat* floats = env->GetFloatArrayElements(v, 0);
    size_t len = env->GetArrayLength(v);
    float* elems = (float*)buf->appendVarying(len, sizeof(float));
    memcpy(elems, floats, len*sizeof(float));    
    cli_array_t* arr = (cli_array_t*)buf->appendFixed(sizeof(cli_array_t), sizeof(void*));
    arr->size = len;
    arr->data = elems;
    arr->allocated = 0;
    env->ReleaseFloatArrayElements(v, floats, 0);
}

void JNICALL   jniSetDoubleArray(JNIEnv* env, jclass, jlong bptr, jdoubleArray v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    jdouble* doubles = env->GetDoubleArrayElements(v, 0);
    size_t len = env->GetArrayLength(v);
    double* elems = (double*)buf->appendVarying(len, sizeof(double));
    memcpy(elems, doubles, len*sizeof(double));    
    cli_array_t* arr = (cli_array_t*)buf->appendFixed(sizeof(cli_array_t), sizeof(void*));
    arr->size = len;
    arr->data = elems;
    arr->allocated = 0;
    env->ReleaseDoubleArrayElements(v, doubles, 0);
}

void JNICALL   jniSetStringArray(JNIEnv* env, jclass, jlong bptr, jobjectArray v)
{
    ObjectBuffer* buf = (ObjectBuffer*)bptr;
    int len = (int)env->GetArrayLength(v);
    size_t total_length = 0;
    int i;
    for (i = 0; i < len; i++) { 
        total_length += getStringLength(env, (jstring)env->GetObjectArrayElement(v, i));
    }
    char** elems = (char**)buf->appendVarying(len + ((total_length+len) + sizeof(char*) - 1) / sizeof(char*), sizeof(char*));
    char* body = (char*)(elems + len);
    for (i = 0; i < len; i++) { 
        jstring str = (jstring)env->GetObjectArrayElement(v, i);
        char const* sb = getStringBody(env, str);
        size_t strlen =  getStringLength(env, str);
        elems[i] = body;
        memcpy(body, sb, strlen);
        body += strlen;
        *body++ = 0;
        releaseStringBody(env, str, sb);
    }
    cli_array_t* arr = (cli_array_t*)buf->appendFixed(sizeof(cli_array_t), sizeof(void*));
    arr->size = len;
    arr->data = elems;
    arr->allocated = 0;
}


jlong JNICALL   jniCreateTable(JNIEnv* env, jclass, jlong db, jstring table, jlong desc)
{
    char const* name = getStringBody(env, table);
    dbTableDescriptor* td = ((JniDatabase*)db)->createTable(name, (ClassDescriptor*)desc);
    releaseStringBody(env, table, name);
    return (jlong)td;
}

jlong jniNext(JNIEnv* env, jclass, jlong cursor)
{
    return (jlong)((JniResultSet*)cursor)->next();
}

jbyte JNICALL   jniGetByte(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextByte();
}

jshort JNICALL  jniGetShort(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextShort();
}

jint JNICALL    jniGetInt(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextInt();
}

jlong JNICALL   jniGetLong(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextLong();
}


jstring JNICALL jniGetString(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextString(env);
}

jbooleanArray JNICALL jniGetBoolArray(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextBoolArray(env);
}

jcharArray JNICALL jniGetCharArray(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextCharArray(env);
}

jbyteArray JNICALL jniGetByteArray(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextByteArray(env);
}

jshortArray JNICALL jniGetShortArray(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextShortArray(env);
}

jintArray JNICALL jniGetIntArray(JNIEnv* env, jclass, jlong cursor)
{
    return ((JniResultSet*)cursor)->nextIntArray(env);