mirror of
https://github.com/mdbtools/mdbtools.git
synced 2025-04-05 20:31:00 +08:00
Use more appropriate types (void *, size_t)
This commit is contained in:
whydoubt
parent
d0474b4692
commit
22c3b15218
@ -1,3 +1,12 @@
|
||||
Mon Jun 27 23:52:15 CDT 2005 Jeff Smith <whydoubt@yahoo.com>
|
||||
* include/mdbtools.h:
|
||||
* src/gmdb2/debug.c:
|
||||
* src/libmdb/data.c:
|
||||
* src/libmdb/file.c:
|
||||
* src/libmdb/write.c:
|
||||
* src/util/prfreemap.c:
|
||||
* src/util/prindex.c: Use more appropriate types (void *, size_t)
|
||||
|
||||
Thu Jun 23 00:40:32 CDT 2005 Jeff Smith <whydoubt@yahoo.com>
|
||||
* src/libmdb/write.c: Use col->is_fixed member directly
|
||||
* doc/reference/libmdb/libmdb-sections.txt:
|
||||
|
||||
@ -337,11 +337,11 @@ typedef struct {
|
||||
int noskip_del; /* don't skip deleted rows */
|
||||
/* object allocation map */
|
||||
guint32 map_base_pg;
|
||||
unsigned int map_sz;
|
||||
size_t map_sz;
|
||||
unsigned char *usage_map;
|
||||
/* pages with free space left */
|
||||
guint32 freemap_base_pg;
|
||||
unsigned int freemap_sz;
|
||||
size_t freemap_sz;
|
||||
unsigned char *free_usage_map;
|
||||
/* query planner */
|
||||
MdbSargNode *sarg_tree;
|
||||
@ -441,13 +441,13 @@ extern int mdb_rewind_table(MdbTableDef *table);
|
||||
extern int mdb_fetch_row(MdbTableDef *table);
|
||||
extern int mdb_is_fixed_col(MdbColumn *col);
|
||||
extern char *mdb_col_to_string(MdbHandle *mdb, void *buf, int start, int datatype, int size);
|
||||
extern int mdb_find_pg_row(MdbHandle *mdb, int pg_row, void **buf, int *off, int *len);
|
||||
extern int mdb_find_row(MdbHandle *mdb, int row, int *start, int *len);
|
||||
extern int mdb_find_pg_row(MdbHandle *mdb, int pg_row, void **buf, int *off, size_t *len);
|
||||
extern int mdb_find_row(MdbHandle *mdb, int row, int *start, size_t *len);
|
||||
extern int mdb_find_end_of_row(MdbHandle *mdb, int row);
|
||||
extern int mdb_col_fixed_size(MdbColumn *col);
|
||||
extern int mdb_col_disp_size(MdbColumn *col);
|
||||
extern int mdb_ole_read_next(MdbHandle *mdb, MdbColumn *col, void *ole_ptr);
|
||||
extern int mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size);
|
||||
extern size_t mdb_ole_read_next(MdbHandle *mdb, MdbColumn *col, void *ole_ptr);
|
||||
extern size_t mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size);
|
||||
extern void mdb_set_date_fmt(const char *);
|
||||
extern int mdb_read_row(MdbTableDef *table, unsigned int row);
|
||||
|
||||
@ -502,10 +502,10 @@ extern int mdb_crack_row(MdbTableDef *table, int row_start, int row_end, MdbFiel
|
||||
extern guint16 mdb_add_row_to_pg(MdbTableDef *table, unsigned char *row_buffer, int new_row_size);
|
||||
extern int mdb_update_index(MdbTableDef *table, MdbIndex *idx, unsigned int num_fields, MdbField *fields, guint32 pgnum, guint16 rownum);
|
||||
extern int mdb_pack_row(MdbTableDef *table, unsigned char *row_buffer, unsigned int num_fields, MdbField *fields);
|
||||
extern int mdb_replace_row(MdbTableDef *table, int row, unsigned char *new_row, int new_row_size);
|
||||
extern int mdb_replace_row(MdbTableDef *table, int row, void *new_row, int new_row_size);
|
||||
extern int mdb_pg_get_freespace(MdbHandle *mdb);
|
||||
extern int mdb_update_row(MdbTableDef *table);
|
||||
extern unsigned char *mdb_new_data_pg(MdbCatalogEntry *entry);
|
||||
extern void *mdb_new_data_pg(MdbCatalogEntry *entry);
|
||||
|
||||
/* map.c */
|
||||
extern guint32 mdb_map_find_next_freepage(MdbTableDef *table, int row_size);
|
||||
|
||||
@ -42,8 +42,8 @@ static void gmdb_debug_text_off(GtkWidget *textbox);
|
||||
static GtkTreeIter *gmdb_debug_add_item(GtkTreeStore *store, GtkTreeIter *iter, gchar *text, int start, int len);
|
||||
static void gmdb_debug_clear(GladeXML *xml);
|
||||
static void gmdb_debug_dissect(GtkTreeStore *store, char *fbuf, int offset, int len);
|
||||
static guint16 get_uint16(unsigned char *c);
|
||||
static guint32 get_uint32(unsigned char *c);
|
||||
static guint16 get_uint16(void *c);
|
||||
static guint32 get_uint32(void *c);
|
||||
static long gmdb_get_max_page(MdbHandle *mdb);
|
||||
static void gmdb_debug_display(GladeXML *xml, guint32 page);
|
||||
static void gmdb_debug_jump(GladeXML *xml, int msb);
|
||||
@ -412,14 +412,14 @@ int i = 0;
|
||||
return "unknown";
|
||||
}
|
||||
static guint16
|
||||
get_uint16(unsigned char *c)
|
||||
get_uint16(void *c)
|
||||
{
|
||||
guint16 i;
|
||||
memcpy(&i, c, 2);
|
||||
return GINT16_FROM_LE(i);
|
||||
}
|
||||
static guint32
|
||||
get_uint32(unsigned char *c)
|
||||
get_uint32(void *c)
|
||||
{
|
||||
guint32 l;
|
||||
memcpy(&l, c, 4);
|
||||
|
||||
@ -32,7 +32,9 @@ static int _mdb_attempt_bind(MdbHandle *mdb,
|
||||
MdbColumn *col, unsigned char isnull, int offset, int len);
|
||||
static char *mdb_num_to_string(MdbHandle *mdb, int start, int datatype, int prec, int scale);
|
||||
static char *mdb_date_to_string(MdbHandle *mdb, int start);
|
||||
int mdb_copy_ole(MdbHandle *mdb, char *dest, int start, int size);
|
||||
#ifdef MDB_COPY_OLE
|
||||
static size_t mdb_copy_ole(MdbHandle *mdb, char *dest, int start, int size);
|
||||
#endif
|
||||
|
||||
static char date_fmt[64] = "%x %X";
|
||||
|
||||
@ -88,7 +90,7 @@ mdb_bind_column_by_name(MdbTableDef *table, gchar *col_name, void *bind_ptr, int
|
||||
*
|
||||
* Returns: 0 on success. 1 on failure.
|
||||
*/
|
||||
int mdb_find_pg_row(MdbHandle *mdb, int pg_row, void **buf, int *off, int *len)
|
||||
int mdb_find_pg_row(MdbHandle *mdb, int pg_row, void **buf, int *off, size_t *len)
|
||||
{
|
||||
unsigned int pg = pg_row >> 8;
|
||||
unsigned int row = pg_row & 0xff;
|
||||
@ -102,7 +104,7 @@ int mdb_find_pg_row(MdbHandle *mdb, int pg_row, void **buf, int *off, int *len)
|
||||
return 0;
|
||||
}
|
||||
|
||||
int mdb_find_row(MdbHandle *mdb, int row, int *start, int *len)
|
||||
int mdb_find_row(MdbHandle *mdb, int row, int *start, size_t *len)
|
||||
{
|
||||
int rco = mdb->fmt->row_count_offset;
|
||||
int next_start;
|
||||
@ -183,7 +185,9 @@ static int mdb_xfer_bound_ole(MdbHandle *mdb, int start, MdbColumn *col, int len
|
||||
col->cur_value_len = 0;
|
||||
}
|
||||
if (col->bind_ptr || col->len_ptr) {
|
||||
//ret = mdb_copy_ole(mdb, col->bind_ptr, start, len);
|
||||
#ifdef MDB_COPY_OLE
|
||||
ret = mdb_copy_ole(mdb, col->bind_ptr, start, len);
|
||||
#endif
|
||||
memcpy(col->bind_ptr, &mdb->pg_buf[start], MDB_MEMO_OVERHEAD);
|
||||
}
|
||||
if (col->len_ptr) {
|
||||
@ -235,7 +239,8 @@ int mdb_read_row(MdbTableDef *table, unsigned int row)
|
||||
MdbColumn *col;
|
||||
unsigned int i;
|
||||
int rc;
|
||||
int row_start, row_size;
|
||||
int row_start;
|
||||
size_t row_size;
|
||||
int delflag, lookupflag;
|
||||
MdbField fields[256];
|
||||
int num_fields;
|
||||
@ -437,13 +442,13 @@ int i;
|
||||
return text;
|
||||
}
|
||||
#endif
|
||||
int
|
||||
size_t
|
||||
mdb_ole_read_next(MdbHandle *mdb, MdbColumn *col, void *ole_ptr)
|
||||
{
|
||||
guint32 ole_len;
|
||||
void *buf;
|
||||
int row_start;
|
||||
int len;
|
||||
size_t len;
|
||||
|
||||
ole_len = mdb_get_int32(ole_ptr, 0);
|
||||
|
||||
@ -464,13 +469,13 @@ mdb_ole_read_next(MdbHandle *mdb, MdbColumn *col, void *ole_ptr)
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
int
|
||||
size_t
|
||||
mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size)
|
||||
{
|
||||
guint32 ole_len;
|
||||
void *buf;
|
||||
int row_start;
|
||||
int len;
|
||||
size_t len;
|
||||
|
||||
ole_len = mdb_get_int32(ole_ptr, 0);
|
||||
mdb_debug(MDB_DEBUG_OLE,"ole len = %d ole flags = %02x",
|
||||
@ -526,11 +531,12 @@ mdb_ole_read(MdbHandle *mdb, MdbColumn *col, void *ole_ptr, int chunk_size)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
int mdb_copy_ole(MdbHandle *mdb, char *dest, int start, int size)
|
||||
#ifdef MDB_COPY_OLE
|
||||
static size_t mdb_copy_ole(MdbHandle *mdb, char *dest, int start, int size)
|
||||
{
|
||||
guint32 ole_len;
|
||||
gint32 row_start, pg_row;
|
||||
gint32 len;
|
||||
size_t len;
|
||||
void *buf, *pg_buf = mdb->pg_buf;
|
||||
|
||||
if (size<MDB_MEMO_OVERHEAD) {
|
||||
@ -589,11 +595,12 @@ int mdb_copy_ole(MdbHandle *mdb, char *dest, int start, int size)
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
#endif
|
||||
static char *mdb_memo_to_string(MdbHandle *mdb, int start, int size)
|
||||
{
|
||||
guint32 memo_len;
|
||||
gint32 row_start, pg_row;
|
||||
gint32 len;
|
||||
size_t len;
|
||||
void *buf, *pg_buf = mdb->pg_buf;
|
||||
char *text = (char *) g_malloc(MDB_BIND_SIZE);
|
||||
|
||||
@ -803,6 +810,7 @@ char *mdb_col_to_string(MdbHandle *mdb, void *buf, int start, int datatype, int
|
||||
char *text;
|
||||
float tf;
|
||||
double td;
|
||||
void *pg_buf = mdb->pg_buf;
|
||||
|
||||
switch (datatype) {
|
||||
case MDB_BOOL:
|
||||
@ -821,13 +829,13 @@ char *mdb_col_to_string(MdbHandle *mdb, void *buf, int start, int datatype, int
|
||||
mdb_get_int32(buf, start));
|
||||
break;
|
||||
case MDB_FLOAT:
|
||||
tf = mdb_get_single(mdb->pg_buf, start);
|
||||
tf = mdb_get_single(pg_buf, start);
|
||||
text = g_strdup_printf("%.*f",
|
||||
FLT_DIG - floor_log10(tf,1) - 1, tf);
|
||||
trim_trailing_zeros(text);
|
||||
break;
|
||||
case MDB_DOUBLE:
|
||||
td = mdb_get_double(mdb->pg_buf, start);
|
||||
td = mdb_get_double(pg_buf, start);
|
||||
text = g_strdup_printf("%.*f",
|
||||
DBL_DIG - floor_log10(td,0) - 1, td);
|
||||
trim_trailing_zeros(text);
|
||||
@ -837,7 +845,7 @@ char *mdb_col_to_string(MdbHandle *mdb, void *buf, int start, int datatype, int
|
||||
text = g_strdup("");
|
||||
} else {
|
||||
text = (char *) g_malloc(MDB_BIND_SIZE);
|
||||
mdb_unicode2ascii(mdb, mdb->pg_buf + start,
|
||||
mdb_unicode2ascii(mdb, pg_buf + start,
|
||||
size, text, MDB_BIND_SIZE);
|
||||
}
|
||||
break;
|
||||
|
||||
@ -52,7 +52,7 @@ MdbFormatConstants MdbJet3Constants = {
|
||||
2048, 0x08, 12, 25, 27, 31, 35, 36, 43, 8, 13, 16, 1, 18, 39, 3, 14, 5
|
||||
};
|
||||
|
||||
static ssize_t _mdb_read_pg(MdbHandle *mdb, unsigned char *pg_buf, unsigned long pg);
|
||||
static ssize_t _mdb_read_pg(MdbHandle *mdb, void *pg_buf, unsigned long pg);
|
||||
|
||||
/**
|
||||
* mdb_find_file:
|
||||
@ -65,7 +65,7 @@ static ssize_t _mdb_read_pg(MdbHandle *mdb, unsigned char *pg_buf, unsigned long
|
||||
* freeing.
|
||||
**/
|
||||
|
||||
static gchar *mdb_find_file(const char *file_name)
|
||||
static char *mdb_find_file(const char *file_name)
|
||||
{
|
||||
struct stat status;
|
||||
gchar *mdbpath, **dir, *tmpfname;
|
||||
@ -121,7 +121,7 @@ MdbHandle *mdb_open(const char *filename, MdbFileFlags flags)
|
||||
mdb->f = (MdbFile *) g_malloc0(sizeof(MdbFile));
|
||||
mdb->f->refs = 1;
|
||||
mdb->f->fd = -1;
|
||||
mdb->f->filename = (char *) mdb_find_file(filename);
|
||||
mdb->f->filename = mdb_find_file(filename);
|
||||
if (!mdb->f->filename) {
|
||||
fprintf(stderr, "Can't alloc filename\n");
|
||||
mdb_close(mdb);
|
||||
@ -253,7 +253,7 @@ ssize_t mdb_read_alt_pg(MdbHandle *mdb, unsigned long pg)
|
||||
len = _mdb_read_pg(mdb, mdb->alt_pg_buf, pg);
|
||||
return len;
|
||||
}
|
||||
static ssize_t _mdb_read_pg(MdbHandle *mdb, unsigned char *pg_buf, unsigned long pg)
|
||||
static ssize_t _mdb_read_pg(MdbHandle *mdb, void *pg_buf, unsigned long pg)
|
||||
{
|
||||
ssize_t len;
|
||||
struct stat status;
|
||||
@ -289,7 +289,6 @@ char tmpbuf[MDB_PGSIZE];
|
||||
}
|
||||
|
||||
|
||||
/* really stupid, just here for consistancy */
|
||||
unsigned char mdb_get_byte(void *buf, int offset)
|
||||
{
|
||||
return ((unsigned char *)(buf))[offset];
|
||||
|
||||
@ -30,19 +30,19 @@
|
||||
static int mdb_add_row_to_leaf_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg, MdbField *idx_fields, guint32 pgnum, guint16 rownum);
|
||||
|
||||
void
|
||||
_mdb_put_int16(unsigned char *buf, guint32 offset, guint32 value)
|
||||
_mdb_put_int16(void *buf, guint32 offset, guint32 value)
|
||||
{
|
||||
value = GINT32_TO_LE(value);
|
||||
memcpy(buf + offset, &value, 2);
|
||||
}
|
||||
void
|
||||
_mdb_put_int32(unsigned char *buf, guint32 offset, guint32 value)
|
||||
_mdb_put_int32(void *buf, guint32 offset, guint32 value)
|
||||
{
|
||||
value = GINT32_TO_LE(value);
|
||||
memcpy(buf + offset, &value, 4);
|
||||
}
|
||||
void
|
||||
_mdb_put_int32_msb(unsigned char *buf, guint32 offset, guint32 value)
|
||||
_mdb_put_int32_msb(void *buf, guint32 offset, guint32 value)
|
||||
{
|
||||
value = GINT32_TO_BE(value);
|
||||
memcpy(buf + offset, &value, 4);
|
||||
@ -148,7 +148,7 @@ mdb_crack_row(MdbTableDef *table, int row_start, int row_end, MdbField *fields)
|
||||
MdbColumn *col;
|
||||
MdbCatalogEntry *entry = table->entry;
|
||||
MdbHandle *mdb = entry->mdb;
|
||||
unsigned char *pg_buf = mdb->pg_buf;
|
||||
void *pg_buf = mdb->pg_buf;
|
||||
unsigned int row_var_cols=0, row_cols;
|
||||
unsigned char *nullmask;
|
||||
unsigned int bitmask_sz;
|
||||
@ -162,20 +162,20 @@ mdb_crack_row(MdbTableDef *table, int row_start, int row_end, MdbField *fields)
|
||||
}
|
||||
|
||||
if (IS_JET4(mdb)) {
|
||||
row_cols = mdb_get_int16(mdb->pg_buf, row_start);
|
||||
row_cols = mdb_get_int16(pg_buf, row_start);
|
||||
col_count_size = 2;
|
||||
} else {
|
||||
row_cols = pg_buf[row_start];
|
||||
row_cols = mdb_get_byte(pg_buf, row_start);
|
||||
col_count_size = 1;
|
||||
}
|
||||
|
||||
bitmask_sz = (row_cols + 7) / 8;
|
||||
nullmask = &pg_buf[row_end - bitmask_sz + 1];
|
||||
nullmask = pg_buf + row_end - bitmask_sz + 1;
|
||||
|
||||
/* read table of variable column locations */
|
||||
row_var_cols = IS_JET4(mdb) ?
|
||||
mdb_get_int16(mdb->pg_buf, row_end - bitmask_sz - 1) :
|
||||
pg_buf[row_end - bitmask_sz];
|
||||
mdb_get_int16(pg_buf, row_end - bitmask_sz - 1) :
|
||||
mdb_get_byte(pg_buf, row_end - bitmask_sz);
|
||||
var_col_offsets = (unsigned int *)g_malloc((row_var_cols+1)*sizeof(int));
|
||||
if (table->num_var_cols > 0) {
|
||||
if (IS_JET4(mdb)) {
|
||||
@ -211,7 +211,7 @@ mdb_crack_row(MdbTableDef *table, int row_start, int row_end, MdbField *fields)
|
||||
&& (fixed_cols_found < row_fixed_cols)) {
|
||||
col_start = col->fixed_offset + col_count_size;
|
||||
fields[i].start = row_start + col_start;
|
||||
fields[i].value = &pg_buf[row_start + col_start];
|
||||
fields[i].value = pg_buf + row_start + col_start;
|
||||
fields[i].siz = col->col_size;
|
||||
fixed_cols_found++;
|
||||
/* Use col->var_col_num because a deleted column is still
|
||||
@ -220,7 +220,7 @@ mdb_crack_row(MdbTableDef *table, int row_start, int row_end, MdbField *fields)
|
||||
&& (col->var_col_num < row_var_cols)) {
|
||||
col_start = var_col_offsets[col->var_col_num];
|
||||
fields[i].start = row_start + col_start;
|
||||
fields[i].value = &pg_buf[row_start + col_start];
|
||||
fields[i].value = pg_buf + row_start + col_start;
|
||||
fields[i].siz = var_col_offsets[(col->var_col_num)+1] -
|
||||
col_start;
|
||||
} else {
|
||||
@ -356,7 +356,7 @@ mdb_pack_row3(MdbTableDef *table, unsigned char *row_buffer, unsigned int num_fi
|
||||
}
|
||||
|
||||
offset_high = (unsigned char *) g_malloc(var_cols+1);
|
||||
offset_high[0] = (pos << 8) & 0xff;
|
||||
offset_high[0] = (pos >> 8) & 0xff;
|
||||
j = 1;
|
||||
|
||||
/* EOD */
|
||||
@ -367,7 +367,7 @@ mdb_pack_row3(MdbTableDef *table, unsigned char *row_buffer, unsigned int num_fi
|
||||
for (i=num_fields; i>0; i--) {
|
||||
if (!fields[i-1].is_fixed) {
|
||||
row_buffer[pos++] = fields[i-1].offset & 0xff;
|
||||
offset_high[j++] = (fields[i-1].offset << 8) & 0xff;
|
||||
offset_high[j++] = (fields[i-1].offset >> 8) & 0xff;
|
||||
}
|
||||
}
|
||||
|
||||
@ -422,30 +422,24 @@ mdb_pg_get_freespace(MdbHandle *mdb)
|
||||
mdb_debug(MDB_DEBUG_WRITE,"free space left on page = %d", free_end - free_start);
|
||||
return (free_end - free_start);
|
||||
}
|
||||
unsigned char *
|
||||
void *
|
||||
mdb_new_leaf_pg(MdbCatalogEntry *entry)
|
||||
{
|
||||
MdbHandle *mdb = entry->mdb;
|
||||
unsigned char *new_pg;
|
||||
|
||||
new_pg = (unsigned char *) g_malloc0(mdb->fmt->pg_size);
|
||||
void *new_pg = g_malloc0(mdb->fmt->pg_size);
|
||||
|
||||
new_pg[0]=0x04;
|
||||
new_pg[1]=0x01;
|
||||
_mdb_put_int16(new_pg, 2, 0x0104);
|
||||
_mdb_put_int32(new_pg, 4, entry->table_pg);
|
||||
|
||||
return new_pg;
|
||||
}
|
||||
unsigned char *
|
||||
void *
|
||||
mdb_new_data_pg(MdbCatalogEntry *entry)
|
||||
{
|
||||
MdbFormatConstants *fmt = entry->mdb->fmt;
|
||||
unsigned char *new_pg;
|
||||
|
||||
new_pg = (unsigned char *) g_malloc0(fmt->pg_size);
|
||||
void *new_pg = g_malloc0(fmt->pg_size);
|
||||
|
||||
new_pg[0]=0x01;
|
||||
new_pg[1]=0x01;
|
||||
_mdb_put_int16(new_pg, 2, 0x0101);
|
||||
_mdb_put_int16(new_pg, 2, fmt->pg_size - fmt->row_count_offset - 2);
|
||||
_mdb_put_int32(new_pg, 4, entry->table_pg);
|
||||
|
||||
@ -574,8 +568,9 @@ mdb_insert_row(MdbTableDef *table, int num_fields, MdbField *fields)
|
||||
guint16
|
||||
mdb_add_row_to_pg(MdbTableDef *table, unsigned char *row_buffer, int new_row_size)
|
||||
{
|
||||
unsigned char *new_pg;
|
||||
int num_rows, i, pos, row_start, row_size;
|
||||
void *new_pg;
|
||||
int num_rows, i, pos, row_start;
|
||||
size_t row_size;
|
||||
MdbCatalogEntry *entry = table->entry;
|
||||
MdbHandle *mdb = entry->mdb;
|
||||
MdbFormatConstants *fmt = mdb->fmt;
|
||||
@ -606,14 +601,14 @@ mdb_add_row_to_pg(MdbTableDef *table, unsigned char *row_buffer, int new_row_siz
|
||||
for (i=0;i<num_rows;i++) {
|
||||
mdb_find_row(mdb, i, &row_start, &row_size);
|
||||
pos -= row_size;
|
||||
memcpy(&new_pg[pos], &mdb->pg_buf[row_start], row_size);
|
||||
memcpy(new_pg + pos, mdb->pg_buf + row_start, row_size);
|
||||
_mdb_put_int16(new_pg, (fmt->row_count_offset + 2) + (i*2), pos);
|
||||
}
|
||||
}
|
||||
|
||||
/* add our new row */
|
||||
pos -= new_row_size;
|
||||
memcpy(&new_pg[pos], row_buffer, new_row_size);
|
||||
memcpy(new_pg + pos, row_buffer, new_row_size);
|
||||
/* add row to the row offset table */
|
||||
_mdb_put_int16(new_pg, (fmt->row_count_offset + 2) + (num_rows*2), pos);
|
||||
|
||||
@ -642,7 +637,7 @@ MdbCatalogEntry *entry = table->entry;
|
||||
MdbHandle *mdb = entry->mdb;
|
||||
MdbField fields[256];
|
||||
unsigned char row_buffer[4096];
|
||||
int old_row_size, new_row_size, delta;
|
||||
size_t old_row_size, new_row_size;
|
||||
unsigned int num_fields;
|
||||
|
||||
if (!mdb->f->writable) {
|
||||
@ -683,8 +678,7 @@ unsigned int num_fields;
|
||||
new_row_size = mdb_pack_row(table, row_buffer, num_fields, fields);
|
||||
if (mdb_get_option(MDB_DEBUG_WRITE))
|
||||
buffer_dump(row_buffer, 0, new_row_size-1);
|
||||
delta = new_row_size - old_row_size;
|
||||
if ((mdb_pg_get_freespace(mdb) - delta) < 0) {
|
||||
if (new_row_size > (old_row_size + mdb_pg_get_freespace(mdb))) {
|
||||
fprintf(stderr, "No space left on this page, update will not occur\n");
|
||||
return 0;
|
||||
}
|
||||
@ -693,15 +687,16 @@ unsigned int num_fields;
|
||||
return 0;
|
||||
}
|
||||
int
|
||||
mdb_replace_row(MdbTableDef *table, int row, unsigned char *new_row, int new_row_size)
|
||||
mdb_replace_row(MdbTableDef *table, int row, void *new_row, int new_row_size)
|
||||
{
|
||||
MdbCatalogEntry *entry = table->entry;
|
||||
MdbHandle *mdb = entry->mdb;
|
||||
int pg_size = mdb->fmt->pg_size;
|
||||
int rco = mdb->fmt->row_count_offset;
|
||||
unsigned char *new_pg;
|
||||
void *new_pg;
|
||||
guint16 num_rows;
|
||||
int row_start, row_size;
|
||||
int row_start;
|
||||
size_t row_size;
|
||||
int i, pos;
|
||||
|
||||
if (mdb_get_option(MDB_DEBUG_WRITE)) {
|
||||
@ -720,20 +715,20 @@ int i, pos;
|
||||
for (i=0;i<row;i++) {
|
||||
mdb_find_row(mdb, i, &row_start, &row_size);
|
||||
pos -= row_size;
|
||||
memcpy(&new_pg[pos], &mdb->pg_buf[row_start], row_size);
|
||||
memcpy(new_pg + pos, mdb->pg_buf + row_start, row_size);
|
||||
_mdb_put_int16(new_pg, rco + 2 + i*2, pos);
|
||||
}
|
||||
|
||||
/* our row */
|
||||
pos -= new_row_size;
|
||||
memcpy(&new_pg[pos], new_row, new_row_size);
|
||||
memcpy(new_pg + pos, new_row, new_row_size);
|
||||
_mdb_put_int16(new_pg, rco + 2 + row*2, pos);
|
||||
|
||||
/* rows after */
|
||||
for (i=row+1;i<num_rows;i++) {
|
||||
mdb_find_row(mdb, i, &row_start, &row_size);
|
||||
pos -= row_size;
|
||||
memcpy(&new_pg[pos], &mdb->pg_buf[row_start], row_size);
|
||||
memcpy(new_pg + pos, mdb->pg_buf + row_start, row_size);
|
||||
_mdb_put_int16(new_pg, rco + 2 + i*2, pos);
|
||||
}
|
||||
|
||||
@ -766,7 +761,7 @@ mdb_copy_index_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg)
|
||||
MdbColumn *col;
|
||||
guint32 pg, pg_row;
|
||||
guint16 row;
|
||||
unsigned char *new_pg;
|
||||
void *new_pg;
|
||||
unsigned char key_hash[256];
|
||||
unsigned char iflag;
|
||||
int keycol;
|
||||
@ -812,7 +807,7 @@ mdb_copy_index_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg)
|
||||
buffer_dump(key_hash, 0, col->col_size - 1);
|
||||
}
|
||||
|
||||
memcpy(&new_pg[ipg->offset], &mdb->pg_buf[ipg->offset], ipg->len);
|
||||
memcpy(new_pg + ipg->offset, mdb->pg_buf + ipg->offset, ipg->len);
|
||||
ipg->offset += ipg->len;
|
||||
ipg->len = 0;
|
||||
|
||||
@ -831,8 +826,8 @@ mdb_copy_index_pg(MdbTableDef *table, MdbIndex *idx, MdbIndexPage *ipg)
|
||||
buffer_dump(key_hash, 0, col->col_size-1);
|
||||
printf("--------\n");
|
||||
}
|
||||
new_pg[ipg->offset] = 0x7f;
|
||||
memcpy(&new_pg[ipg->offset + 1], key_hash, col->col_size);
|
||||
((char *)new_pg)[ipg->offset] = 0x7f;
|
||||
memcpy(new_pg + ipg->offset + 1, key_hash, col->col_size);
|
||||
pg_row = (pgnum << 8) | ((rownum-1) & 0xff);
|
||||
_mdb_put_int32_msb(new_pg, ipg->offset + 5, pg_row);
|
||||
ipg->idx_starts[row++] = ipg->offset + ipg->len;
|
||||
|
||||
@ -25,7 +25,8 @@ main(int argc, char **argv)
|
||||
{
|
||||
MdbHandle *mdb;
|
||||
int j;
|
||||
long int pgnum = 0, row_start, map_sz;
|
||||
long int pgnum = 0, row_start;
|
||||
size_t map_sz;
|
||||
int coln = 1;
|
||||
unsigned char *map_buf;
|
||||
|
||||
|
||||
@ -80,7 +80,8 @@ void check_row(MdbHandle *mdb, MdbIndex *idx, guint32 pg, int row, unsigned char
|
||||
{
|
||||
MdbField fields[256];
|
||||
unsigned int num_fields, i, j;
|
||||
int row_start, row_size;
|
||||
int row_start;
|
||||
size_t row_size;
|
||||
MdbColumn *col;
|
||||
gchar buf[256], key[256];
|
||||
int elem;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user