← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/pbxt/src/table_xt.cc

  • Committer: Brian Aker
  • Date: 2010-05-03 20:01:36 UTC
  • mfrom: (1516.1.2 staging)
  • Revision ID: brian@gaz-20100503200136-8cbqn0m5hztqb9h8
Merge Paul's latest PBXT (includes version 1.1)

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/pbxt/src/table_xt.cc
537
537
                                else if (strcmp(name, "type") == 0) {
538
538
                                        u_long lvalue = 0;
539
539
 
540
 
                                        sscanf(value, "%lu", &lvalue);
541
 
                                        td->td_tab_type = (xtWord1) lvalue;
 
540
                                        sscanf(value, "%lu", &lvalue);
 
541
                                        td->td_tab_type = (xtWord1) lvalue;
542
542
                                } 
543
543
                                else if (strcmp(name, "[table]") == 0)
544
544
                                        break;
1292
1292
        XTOpenFilePtr   of_rec, of_ind;
1293
1293
        XTTableEntryPtr te_ptr;
1294
1294
        size_t                  tab_format_offset;
1295
 
        size_t                  tab_head_size= 0;
 
1295
        size_t                  tab_head_size = 0;
1296
1296
 
1297
1297
        enter_();
1298
1298
 
1579
1579
        }
1580
1580
}
1581
1581
 
1582
 
static void tab_init_row_file(XTThreadPtr self, XTOpenFilePtr of_row, XTTableHPtr tab, XTDictionaryPtr)
 
1582
static void tab_init_row_file(XTThreadPtr self, XTOpenFilePtr of_row, XTTableHPtr tab, XTDictionaryPtr XT_UNUSED(dic))
1583
1583
{
1584
1584
        XTTabRowHeadDRec        row_head;
1585
1585
 
4442
4442
u_int           next_off_page = 0;
4443
4443
#endif
4444
4444
 
 
4445
static xtBool tab_write_ext_record(XTOpenTablePtr XT_UNUSED(ot), XTTableHPtr tab, XTTabRecInfoPtr rec_info, xtRecordID rec_id, xtLogID log_id, xtLogOffset log_offset, XTThreadPtr thread)
 
4446
{
 
4447
        xtWord1 tmp_buffer[offsetof(XTactExtRecEntryDRec, er_data)];
 
4448
        xtBool  ok;
 
4449
 
 
4450
        memcpy(tmp_buffer, rec_info->ri_log_buf, sizeof(tmp_buffer));
 
4451
        rec_info->ri_log_buf->er_status_1 = XT_LOG_ENT_EXT_REC_OK;
 
4452
        XT_SET_DISK_4(rec_info->ri_log_buf->er_data_size_4, rec_info->ri_log_data_size);
 
4453
        XT_SET_DISK_4(rec_info->ri_log_buf->er_tab_id_4, tab->tab_id);
 
4454
        XT_SET_DISK_4(rec_info->ri_log_buf->er_rec_id_4, rec_id);
 
4455
        if (tab->tab_dic.dic_tab_flags & XT_TF_MEMORY_TABLE)
 
4456
                ok = xt_tab_save_ext_record(tab, log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf);
 
4457
        else
 
4458
                ok = thread->st_dlog_buf.dlb_append_log(log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf, thread);
 
4459
        memcpy(rec_info->ri_log_buf, tmp_buffer, sizeof(tmp_buffer));
 
4460
        return ok;
 
4461
}
 
4462
 
4445
4463
static xtBool tab_add_record(XTOpenTablePtr ot, XTTabRecInfoPtr rec_info, u_int status)
4446
4464
{
4447
4465
        register XTTableHPtr    tab = ot->ot_table;
4548
4566
                 */
4549
4567
                read = ((rec_id - 1) % tab->tab_recs.tci_rows_per_page) != 0;
4550
4568
 
4551
 
                if (!tab->tab_recs.xt_tc_write(ot->ot_rec_file, rec_id, 0, rec_info->ri_rec_buf_size, (xtWord1 *) rec_info->ri_fix_rec_buf, &op_seq, read, ot->ot_thread)) {
 
4569
                if (!tab->tab_recs.xt_tc_write(ot->ot_rec_file, rec_id, 0, rec_info->ri_rec_buf_size, (xtWord1 *) rec_info->ri_fix_rec_buf, &op_seq, read, thread)) {
4552
4570
                        xt_unlock_mutex_ns(&tab->tab_rec_lock);
4553
4571
                        return FAILED;
4554
4572
                }
4555
4573
        }
4556
4574
        xt_unlock_mutex_ns(&tab->tab_rec_lock);
4557
4575
 
4558
 
        if (!xt_xlog_modify_table(tab->tab_id, status, op_seq, 0, next_rec_id, rec_id,  rec_info->ri_rec_buf_size, (xtWord1 *) rec_info->ri_fix_rec_buf, ot->ot_thread))
 
4576
        if (!xt_xlog_modify_table(tab->tab_id, status, op_seq, 0, next_rec_id, rec_id,  rec_info->ri_rec_buf_size, (xtWord1 *) rec_info->ri_fix_rec_buf, thread))
4559
4577
                return FAILED;
4560
4578
 
4561
4579
        if (rec_info->ri_ext_rec) {
4562
4580
                /* Write the log buffer overflow: */            
4563
 
                rec_info->ri_log_buf->er_status_1 = XT_LOG_ENT_EXT_REC_OK;
4564
 
                XT_SET_DISK_4(rec_info->ri_log_buf->er_data_size_4, rec_info->ri_log_data_size);
4565
 
                XT_SET_DISK_4(rec_info->ri_log_buf->er_tab_id_4, tab->tab_id);
4566
 
                XT_SET_DISK_4(rec_info->ri_log_buf->er_rec_id_4, rec_id);
4567
 
                if (tab->tab_dic.dic_tab_flags & XT_TF_MEMORY_TABLE) {
4568
 
                        if (!xt_tab_save_ext_record(tab, log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf))
4569
 
                                return FAILED;
4570
 
                }
4571
 
                else {
4572
 
                        if (!thread->st_dlog_buf.dlb_append_log(log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf, ot->ot_thread)) {
4573
 
                                /* Failed to write the overflow, free the record allocated above: */
4574
 
                                return FAILED;
4575
 
                        }
4576
 
                }
 
4581
                if (!tab_write_ext_record(ot, tab, rec_info, rec_id, log_id, log_offset, thread))
 
4582
                        return FAILED;
4577
4583
        }
4578
4584
 
4579
4585
        XT_DISABLED_TRACE(("new rec tx=%d val=%d\n", (int) thread->st_xact_data->xd_start_xn_id, (int) rec_id));
4581
4587
        return OK;
4582
4588
}
4583
4589
 
4584
 
static void tab_delete_record_on_fail(XTOpenTablePtr ot, xtRowID row_id, xtRecordID rec_id, XTTabRecHeadDPtr row_ptr, xtWord1 *rec_data, u_int key_count)
 
4590
static void tab_delete_record_on_fail(XTOpenTablePtr ot, xtRowID row_id, xtRecordID rec_id, XTTabRecHeadDPtr XT_UNUSED(row_ptr), xtWord1 *rec_data, u_int key_count)
4585
4591
{
4586
4592
        XTExceptionRec  e;
4587
4593
        xtBool                  log_err = TRUE;
4609
4615
                }
4610
4616
        }
4611
4617
 
 
4618
        /* This is not required because the extended record will be free
 
4619
         * later when the record is freed!
4612
4620
        if (row_ptr->tr_rec_type_1 == XT_TAB_STATUS_EXT_DLOG || row_ptr->tr_rec_type_1 == XT_TAB_STATUS_EXT_CLEAN)
4613
4621
                tab_free_ext_record_on_fail(ot, rec_id, (XTTabRecExtDPtr) row_ptr, log_err);
 
4622
         */
4614
4623
 
4615
4624
        rec_info.ri_fix_rec_buf = (XTTabRecFixDPtr) ot->ot_row_wbuffer;
4616
4625
        rec_info.ri_rec_buf_size = offsetof(XTTabRecFixDRec, rf_data);
4909
4918
        u_int                                   idx_cnt = 0;
4910
4919
        XTIndexPtr                              *ind;
4911
4920
 
 
4921
        /* A non-temporary table has been updated: */
 
4922
        if (!XT_IS_TEMP_TABLE(tab->tab_dic.dic_tab_flags))
 
4923
                self->st_non_temp_updated = TRUE;
 
4924
 
4912
4925
        if (!myxt_store_row(ot, &rec_info, (char *) rec_buf))
4913
4926
                goto failed_0;
4914
4927
 
5005
5018
                 * order to do this we'd need to read the before-image of the 
5006
5019
                 * record before modifying it.
5007
5020
                 */
5008
 
                if (!ot->ot_thread->t_exception.e_xt_err)
 
5021
                if (!thread->t_exception.e_xt_err)
5009
5022
                        xt_register_xterr(XT_REG_CONTEXT, XT_ERR_NO_BEFORE_IMAGE);
5010
5023
                return FAILED;
5011
5024
        }
5023
5036
                                return FAILED;
5024
5037
                }
5025
5038
                else {
5026
 
                        if (!thread->st_dlog_buf.dlb_get_log_offset(&log_id, &log_offset, rec_info->ri_log_data_size + offsetof(XTactExtRecEntryDRec, er_data), ot->ot_thread))
 
5039
                        if (!thread->st_dlog_buf.dlb_get_log_offset(&log_id, &log_offset, rec_info->ri_log_data_size + offsetof(XTactExtRecEntryDRec, er_data), thread))
5027
5040
                                return FAILED;
5028
5041
                }
5029
5042
                XT_SET_LOG_REF(rec_info->ri_ext_rec, log_id, log_offset);
5034
5047
 
5035
5048
        if (rec_info->ri_ext_rec) {
5036
5049
                /* Write the log buffer overflow: */            
5037
 
                rec_info->ri_log_buf->er_status_1 = XT_LOG_ENT_EXT_REC_OK;
5038
 
                XT_SET_DISK_4(rec_info->ri_log_buf->er_data_size_4, rec_info->ri_log_data_size);
5039
 
                XT_SET_DISK_4(rec_info->ri_log_buf->er_tab_id_4, tab->tab_id);
5040
 
                XT_SET_DISK_4(rec_info->ri_log_buf->er_rec_id_4, rec_id);
5041
 
 
5042
 
                if (tab->tab_dic.dic_tab_flags & XT_TF_MEMORY_TABLE) {
5043
 
                        if (!xt_tab_save_ext_record(tab, log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf))
5044
 
                                return FAILED;
5045
 
                }
5046
 
                else {
5047
 
                        if (!thread->st_dlog_buf.dlb_append_log(log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info->ri_log_data_size, (xtWord1 *) rec_info->ri_log_buf, ot->ot_thread))
5048
 
                                return FAILED;
5049
 
                }
 
5050
                if (!tab_write_ext_record(ot, tab, rec_info, rec_id, log_id, log_offset, thread))
 
5051
                        return FAILED;
5050
5052
        }
5051
5053
 
5052
5054
        /* Put the index entries back: */
5078
5080
        xtLogOffset                             log_offset;
5079
5081
        xtBool                                  prev_ext_rec;
5080
5082
 
 
5083
        /* A non-temporary table has been updated: */
 
5084
        if (!XT_IS_TEMP_TABLE(tab->tab_dic.dic_tab_flags))
 
5085
                self->st_non_temp_updated = TRUE;
 
5086
 
5081
5087
        if (!myxt_store_row(ot, &rec_info, (char *) after_buf))
5082
5088
                goto failed_0;
5083
5089
 
5094
5100
                                goto failed_0;
5095
5101
                }
5096
5102
                else {
5097
 
                        if (!self->st_dlog_buf.dlb_get_log_offset(&log_id, &log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info.ri_log_data_size, ot->ot_thread))
 
5103
                        if (!self->st_dlog_buf.dlb_get_log_offset(&log_id, &log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info.ri_log_data_size, self))
5098
5104
                                goto failed_0;
5099
5105
                }
5100
5106
                XT_SET_LOG_REF(rec_info.ri_ext_rec, log_id, log_offset);
5121
5127
 
5122
5128
        if (rec_info.ri_ext_rec) {
5123
5129
                /* Write the log buffer overflow: */            
5124
 
                rec_info.ri_log_buf->er_status_1 = XT_LOG_ENT_EXT_REC_OK;
5125
 
                XT_SET_DISK_4(rec_info.ri_log_buf->er_data_size_4, rec_info.ri_log_data_size);
5126
 
                XT_SET_DISK_4(rec_info.ri_log_buf->er_tab_id_4, tab->tab_id);
5127
 
                XT_SET_DISK_4(rec_info.ri_log_buf->er_rec_id_4, rec_id);
5128
 
                if (tab->tab_dic.dic_tab_flags & XT_TF_MEMORY_TABLE) {
5129
 
                        if (!xt_tab_save_ext_record(tab, log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info.ri_log_data_size, (xtWord1 *) rec_info.ri_log_buf))
5130
 
                                goto failed_1;
5131
 
                }
5132
 
                else {
5133
 
                        if (!self->st_dlog_buf.dlb_append_log(log_id, log_offset, offsetof(XTactExtRecEntryDRec, er_data) + rec_info.ri_log_data_size, (xtWord1 *) rec_info.ri_log_buf, ot->ot_thread))
5134
 
                                goto failed_1;
5135
 
                }
 
5130
                if (!tab_write_ext_record(ot, tab, &rec_info, rec_id, log_id, log_offset, self))
 
5131
                        goto failed_1;
5136
5132
        }
5137
5133
 
5138
5134
        /* Add the index references that have changed: */
5247
5243
        row_id = ot->ot_curr_row_id;
5248
5244
        self = ot->ot_thread;
5249
5245
 
 
5246
        /* A non-temporary table has been updated: */
 
5247
        if (!XT_IS_TEMP_TABLE(tab->tab_dic.dic_tab_flags))
 
5248
                self->st_non_temp_updated = TRUE;
 
5249
 
5250
5250
        if (!myxt_store_row(ot, &rec_info, (char *) after_buf))
5251
5251
                goto failed_0;
5252
5252
 
5260
5260
                goto failed_0;
5261
5261
 
5262
5262
        /* Link the new variation into the list: */
5263
 
        XT_TAB_ROW_WRITE_LOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
 
5263
        XT_TAB_ROW_WRITE_LOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], self);
5264
5264
 
5265
5265
        if (!xt_tab_get_row(ot, row_id, &curr_var_rec_id))
5266
5266
                goto failed_1;
5286
5286
                goto failed_1;
5287
5287
        XT_DISABLED_TRACE(("set upd tx=%d row=%d rec=%d\n", (int) self->st_xact_data->xd_start_xn_id, (int) row_id, (int) rec_info.ri_rec_id));
5288
5288
 
5289
 
        XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
 
5289
        XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], self);
5290
5290
 
5291
5291
        /* Add the index references: */
5292
5292
        for (idx_cnt=0, ind=tab->tab_dic.dic_keys; idx_cnt<tab->tab_dic.dic_key_count; idx_cnt++, ind++) {
5301
5301
                        goto failed_2;
5302
5302
        }
5303
5303
 
5304
 
        ot->ot_thread->st_statistics.st_row_update++;
 
5304
        self->st_statistics.st_row_update++;
5305
5305
        return OK;
5306
5306
 
5307
5307
        failed_2:
5309
5309
        goto failed_0;
5310
5310
 
5311
5311
        failed_1:
5312
 
        XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
 
5312
        XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], self);
5313
5313
 
5314
5314
        failed_0:
5315
5315
        return FAILED;
5318
5318
xtPublic xtBool xt_tab_delete_record(XTOpenTablePtr ot, xtWord1 *rec_buf)
5319
5319
{
5320
5320
        register XTTableHPtr    tab = ot->ot_table;
 
5321
        register XTThreadPtr    thread = ot->ot_thread;
5321
5322
        xtRowID                                 row_id = ot->ot_curr_row_id;
5322
5323
        xtRecordID                              curr_var_rec_id;
5323
5324
        XTTabRecInfoRec                 rec_info;
5324
5325
 
 
5326
        /* A non-temporary table has been updated: */
 
5327
        if (!XT_IS_TEMP_TABLE(tab->tab_dic.dic_tab_flags))
 
5328
                thread->st_non_temp_updated = TRUE;
 
5329
 
5325
5330
        /* Setup a delete record: */
5326
5331
        rec_info.ri_fix_rec_buf = (XTTabRecFixDPtr) ot->ot_row_wbuffer;
5327
5332
        rec_info.ri_rec_buf_size = offsetof(XTTabRecFixDRec, rf_data);
5330
5335
        rec_info.ri_fix_rec_buf->tr_stat_id_1 = 0;
5331
5336
        XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_row_id_4, row_id);
5332
5337
        XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_prev_rec_id_4, ot->ot_curr_rec_id);
5333
 
        XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_xact_id_4, ot->ot_thread->st_xact_data->xd_start_xn_id);
 
5338
        XT_SET_DISK_4(rec_info.ri_fix_rec_buf->tr_xact_id_4, thread->st_xact_data->xd_start_xn_id);
5334
5339
 
5335
5340
        if (!tab_add_record(ot, &rec_info, XT_LOG_ENT_DELETE))
5336
5341
                return FAILED;
5337
5342
 
5338
 
        XT_TAB_ROW_WRITE_LOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
 
5343
        XT_TAB_ROW_WRITE_LOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], thread);
5339
5344
 
5340
5345
        if (!xt_tab_get_row(ot, row_id, &curr_var_rec_id))
5341
5346
                goto failed_1;
5346
5351
        }
5347
5352
 
5348
5353
#ifdef TRACE_VARIATIONS
5349
 
        xt_ttracef(ot->ot_thread, "update: row=%d rec=%d T%d\n", (int) row_id, (int) rec_info.ri_rec_id, (int) ot->ot_thread->st_xact_data->xd_start_xn_id);
 
5354
        xt_ttracef(thread, "update: row=%d rec=%d T%d\n", (int) row_id, (int) rec_info.ri_rec_id, (int) thread->st_xact_data->xd_start_xn_id);
5350
5355
#endif
5351
5356
        if (!xt_tab_set_row(ot, XT_LOG_ENT_ROW_ADD_REC, row_id, rec_info.ri_rec_id))
5352
5357
                goto failed_1;
5353
 
        XT_DISABLED_TRACE(("del row tx=%d row=%d rec=%d\n", (int) ot->ot_thread->st_xact_data->xd_start_xn_id, (int) row_id, (int) rec_info.ri_rec_id));
 
5358
        XT_DISABLED_TRACE(("del row tx=%d row=%d rec=%d\n", (int) thread->st_xact_data->xd_start_xn_id, (int) row_id, (int) rec_info.ri_rec_id));
5354
5359
 
5355
 
        XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
 
5360
        XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], thread);
5356
5361
 
5357
5362
        if (ot->ot_table->tab_dic.dic_table->dt_trefs) {
5358
5363
                if (!ot->ot_table->tab_dic.dic_table->deleteRow(ot, rec_buf))
5359
5364
                        goto failed_2;
5360
5365
        }
5361
5366
 
5362
 
        ot->ot_thread->st_statistics.st_row_delete++;
 
5367
        thread->st_statistics.st_row_delete++;
5363
5368
        return OK;
5364
5369
 
5365
5370
        failed_2:
5367
5372
        return FAILED;
5368
5373
 
5369
5374
        failed_1:
5370
 
        XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], ot->ot_thread);
 
5375
        XT_TAB_ROW_UNLOCK(&tab->tab_row_rwlock[row_id % XT_ROW_RWLOCKS], thread);
5371
5376
        return FAILED;
5372
5377
}
5373
5378
 
5880
5885
 * EXTENDED DATA FOR RAM TABLES
5881
5886
 */
5882
5887
 
5883
 
xtPublic xtBool xt_tab_get_ext_slot(XTTableHPtr tab, xtLogID *log_id, xtLogOffset *log_offset, size_t /*req_size*/)
 
5888
xtPublic xtBool xt_tab_get_ext_slot(XTTableHPtr tab, xtLogID *log_id, xtLogOffset *log_offset, size_t XT_UNUSED(req_size))
5884
5889
{
5885
5890
        size_t new_slot;
5886
5891