dBase Level 7 Dateien lesen - und MDX

J

jkallup

Erfahrenes Mitglied
Hallo,

anbei die ersten Gehversuche, dBase 7 Dateien zu lesen.
Wie kann ich Felder auslesen?
Wie kann ich Indexe auslesen?

Danke für Hilfe
 

Anhänge

Hallo,

habe nun folgenden Code, der Level 7 Dateien öffnen kann.
Leider kann habe ich Probleme einen einzelnen Record oder vielmehr
ein Datenfeld auszulesen.
Wie macht man das dynamisch? mit scanf?
siehe Zeile: 152 ff.
Gruß
jkallup

Code: 
#ifndef __XBASE_H__
#define __XBASE_H__

#include <QObject>
#include <QString>
#include <QStringList>
#include <QMessageBox>
#include <QVector>
#include <QMap>
#include "MyQVariant.h"
#include "dbf.h"

extern void xbase_add_path(QString);
extern void xbase_open_dbf(QString);
extern void xbase_select(int);
extern void xbase_print_field(QString);

class MyQMemoryTable
{
public:
    MyQMemoryTable() { }
    QString value_text;
};

class MyQWorkArea
{
public:
    MyQWorkArea(QString);

    void dbf_read_header(void);
    void dbf_read_fields(void);

    QString dbFile;
    int     dbHandle;
    int     dbVersion;

    class   QMap<QString , QVector<MyQMemoryTable> > content;

    struct  DB_HEADER db_buf, *db;
    struct  DB_FIELD *header;

    int     header_length;
    int     record_length;
};

namespace mydata
{
#ifdef __MAIN_RUN__
    class QStringList  data_paths;
    class QVector<MyQWorkArea*> wa;
#else
    extern class QStringList  data_paths;
    extern class QVector<MyQWorkArea*> wa;
#endif
}

#endif



Code: 
#include <QObject>
#include <QString>
#include <QStringList>
#include <QMessageBox>
#include <QVector>

#include "MyQVariant.h"
#include "xbase.h"

extern "C" void DisplayErrorMessage(int line,char *msg)
{
    QMessageBox* msgBox = new QMessageBox();
    msgBox->setWindowTitle("Programmfehler!");
    msgBox->setText(QString("Error: %1: %2").arg(line).arg(msg));
    msgBox->exec();
}

void xbase_add_path(QString str)
{
    mydata::data_paths << str;
}

void xbase_select(int w)
{

}

void xbase_open_dbf(QString str)
{
    QString dbf;

    if (!str.contains(".dbf"))
        str = str + QString(".dbf");

    int i;
    FILE *data = NULL;
    bool found = false;

    for (i = 0; i < mydata::data_paths.count(); i++)
    {
        dbf = QString(mydata::data_paths.at(i) + "\\" + str);
        if ((data = fopen(QString(dbf).toStdString().c_str(),"rb")) != NULL)
        {
            fclose(data);
            found = true;
            break;
        }
    }

    if (found == false)
        str = str + QString(" not found"); else
        str = str + QString(" was found");
    print_console(str);

    MyQWorkArea *WA = new MyQWorkArea(dbf);
    mydata::wa.append(WA);
}

MyQWorkArea::MyQWorkArea(QString dbf)
{
    this->dbFile = dbf;

    if ((dbHandle = open(dbf.toStdString().c_str(), O_RDONLY|O_BINARY)) == -1) {
        msgbox("Fehler",QString("Kann Datei: %1\nnicht öffnen").arg(dbf));
        return;
    }

    db = &db_buf;

    dbf_read_header();
    dbf_read_fields();
}

void MyQWorkArea::dbf_read_header(void)
{
    if ((read(dbHandle, (char *)db, sizeof(struct DB_HEADER))) == -1 ) {
        msgbox("Fehler!","kann dbf Header nicht lesen.");
        return;
    }

    this->dbVersion     = db->version;
    this->header_length = rotate2b(db->header_length) / 32;
    this->record_length = rotate2b(db->record_length);
}

void MyQWorkArea::dbf_read_fields(void)
{
    struct DB_FIELD *hdr;
    unsigned char *record;
    class QMap<QString, int> field;

    header = (struct DB_FIELD*) malloc(sizeof(struct DB_FIELD) * header_length);
    if (header == NULL) {
        msgbox("Fehler","kann keimn Speicher anfordern.");
        return;
    }

    lseek(dbHandle, header_length, SEEK_SET);
    char c[1];
    int pos = 0;
    int h;
    while (1)
    {
        read(dbHandle,c,1);
        if (c[0] == 0x0d) break;
        pos++;
    }
    int psize = pos / sizeof(struct DB_FIELD);
    psize--;
    lseek(dbHandle, 0, SEEK_SET);
    dbf_read_header();

    print_console(QString("\n::> %1, %2").arg(pos).arg(psize));
    for (hdr = header + 1; --header_length; hdr++)
    {
        if (psize-- < 1) break;
        if((read(dbHandle, header, sizeof(struct DB_FIELD))) == -1) {
            msgbox("Fehler","kann Feld nicht einlesen.");
            return;
        }

        field.insert(QString((char*)header->field_name,header->length_binary);
        
        //print_console(QString("---> %1 , %2").arg((char*)header->field_name).arg(header->length_binary));
    }

    if ((record = (unsigned char*) malloc(record_length + 1)) == NULL)	{
        perror("malloc");
        exit(1);
    }
    record[record_length] = '\0';

    char *flag_byte;
    lseek(dbHandle, rotate2b(db->header_length), SEEK_SET);

    if ( (flag_byte = (char*)malloc(1)) == NULL ) {
        msgbox("Fehler!","kann kein Speicher zuweisen.");
        exit(1);
    }

    if (read(dbHandle, flag_byte, 1) == -1) {
        msgbox("Fehler","reading Flag Byte");
        exit(1);
    }

    *flag_byte = *(record + record_length - 1);

    MyQMemoryTable mt;
    QVector<class MyQMemoryTable> memtab;

    for (int i = 0; i < db->records; i++)
    {
        read(dbHandle, record, record_length);
        record[record_length-1] = '\0';
        print_console(QString(":::>> %1").arg((char*)record));

        for (int f = 0; f < field.count(); f++)
        {
        }
                    
        mt.value_text = QString((char*)record);
        memtab.push_back(mt);
    }
    //mt.value_text = "Fritz";    memtab.push_back(mt);
    //mt.value_text = "Alfonso";  memtab.push_back(mt);

    //print_console("append");
    content.insert(QString((char*)header->field_name),memtab);

    free(record);

//print_console(content["vorname"].at(0).value_text);
//print_console(content["vorname"].at(1).value_text);

}

void xbase_print_field(QString field)
{
    MyQWorkArea *wa = mydata::wa.at(0);

    print_console(wa->dbFile);
    print_console(wa->record_length);
    print_console(wa->content[field].at(1).value_text);
}
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück