~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/row/row0upd.c

• browse files at revision 2012
• compare with another revision
• download diff
• download tarball
• view history from revision 2012

• reverse the comparison (2012 to 2165.1.3)
• stop comparing with revision 2165.1.3

Show diffs side-by-side

added

removed

plugin/innobase/row/row0upd.c

313

313

{

314

314

        upd_node_t*     node;

315

315

 

316

 

        node = static_cast<upd_node_t *>(mem_heap_alloc(heap, sizeof(upd_node_t)));

 

316

        node = mem_heap_alloc(heap, sizeof(upd_node_t));

317

317

        node->common.type = QUE_NODE_UPDATE;

318

318

 

319

319

        node->state = UPD_NODE_UPDATE_CLUSTERED;

381

381

void

382

382

row_upd_index_entry_sys_field(

383

383

/*==========================*/

384

 

        dtuple_t*       entry,  /*!< in/out: index entry, where the memory

385

 

                                buffers for sys fields are already allocated:

 

384

        const dtuple_t* entry,  /*!< in: index entry, where the memory buffers

 

385

                                for sys fields are already allocated:

386

386

                                the function just copies the new values to

387

387

                                them */

388

388

        dict_index_t*   index,  /*!< in: clustered index */

398

398

        pos = dict_index_get_sys_col_pos(index, type);

399

399

 

400

400

        dfield = dtuple_get_nth_field(entry, pos);

401

 

        field = static_cast<byte *>(dfield_get_data(dfield));

 

401

        field = dfield_get_data(dfield);

402

402

 

403

403

        if (type == DATA_TRX_ID) {

404

404

                trx_write_trx_id(field, val);

476

476

#endif /* !UNIV_HOTBACKUP */

477

477

 

478

478

/***********************************************************//**

479

 

Replaces the new column values stored in the update vector to the

480

 

record given. No field size changes are allowed. This function is

481

 

usually invoked on a clustered index. The only use case for a

482

 

secondary index is row_ins_sec_index_entry_by_modify() or its

483

 

counterpart in ibuf_insert_to_index_page(). */

 

479

Replaces the new column values stored in the update vector to the record

 

480

given. No field size changes are allowed. */

484

481

UNIV_INTERN

485

482

void

486

483

row_upd_rec_in_place(

537

534

        roll_ptr_t      roll_ptr,/*!< in: roll ptr of the undo log record */

538

535

        byte*           log_ptr,/*!< pointer to a buffer of size > 20 opened

539

536

                                in mlog */

540

 

        mtr_t*          /*mtr __attribute__((unused))*/) /*!< in: mtr */

 

537

        mtr_t*          mtr __attribute__((unused))) /*!< in: mtr */

541

538

{

542

539

        ut_ad(dict_index_is_clust(index));

543

540

        ut_ad(mtr);

648

645

                                mlog_close(mtr, log_ptr);

649

646

 

650

647

                                mlog_catenate_string(mtr,

651

 

                                                     static_cast<byte *>(dfield_get_data(new_val)),

 

648

                                                     dfield_get_data(new_val),

652

649

                                                     len);

653

650

 

654

651

                                log_ptr = mlog_open(mtr, MLOG_BUF_MARGIN);

907

904

                                        out: fetched length of the prefix */

908

905

        mem_heap_t*     heap)           /*!< in: heap where to allocate */

909

906

{

910

 

        byte* buf = static_cast<byte *>(mem_heap_alloc(heap, *len));

 

907

        byte*   buf = mem_heap_alloc(heap, *len);

911

908

 

912

909

        *len = btr_copy_externally_stored_field_prefix(buf, *len,

913

910

                                                       zip_size,

945

942

        }

946

943

 

947

944

        len = dfield_get_len(dfield);

948

 

        data = static_cast<const byte *>(dfield_get_data(dfield));

 

945

        data = dfield_get_data(dfield);

949

946

 

950

947

        if (field->prefix_len > 0) {

951

948

                ibool           fetch_ext = dfield_is_ext(dfield)

996

993

                stored part of the column.  The data

997

994

                will have to be copied. */

998

995

                ut_a(uf->orig_len > BTR_EXTERN_FIELD_REF_SIZE);

999

 

                buf = static_cast<byte *>(mem_heap_alloc(heap, uf->orig_len));

 

996

                buf = mem_heap_alloc(heap, uf->orig_len);

1000

997

                /* Copy the locally stored prefix. */

1001

998

                memcpy(buf, data,

1002

999

                       uf->orig_len - BTR_EXTERN_FIELD_REF_SIZE);

1146

1143

        table = index->table;

1147

1144

        ut_ad(n_cols == dict_table_get_n_cols(table));

1148

1145

 

1149

 

        ext_cols = static_cast<ulint *>(mem_heap_alloc(heap, n_cols * sizeof *ext_cols));

 

1146

        ext_cols = mem_heap_alloc(heap, n_cols * sizeof *ext_cols);

1150

1147

        n_ext_cols = 0;

1151

1148

 

1152

1149

        dtuple_set_info_bits(row, update->info_bits);

1625

1622

ulint

1626

1623

row_upd_clust_rec_by_insert(

1627

1624

/*========================*/

1628

 

        upd_node_t*     node,   /*!< in/out: row update node */

 

1625

        upd_node_t*     node,   /*!< in: row update node */

1629

1626

        dict_index_t*   index,  /*!< in: clustered index of the record */

1630

1627

        que_thr_t*      thr,    /*!< in: query thread */

1631

1628

        ibool           referenced,/*!< in: TRUE if index may be referenced in

1632

1629

                                a foreign key constraint */

1633

 

        mtr_t*          mtr)    /*!< in/out: mtr; gets committed here */

 

1630

        mtr_t*          mtr)    /*!< in: mtr; gets committed here */

1634

1631

{

1635

1632

        mem_heap_t*     heap    = NULL;

1636

1633

        btr_pcur_t*     pcur;

1651

1648

 

1652

1649

        if (node->state != UPD_NODE_INSERT_CLUSTERED) {

1653

1650

                rec_t*          rec;

1654

 

                dict_index_t*   node_index;

 

1651

                dict_index_t*   index;

1655

1652

                ulint           offsets_[REC_OFFS_NORMAL_SIZE];

1656

1653

                ulint*          offsets;

1657

1654

                rec_offs_init(offsets_);

1669

1666

                record is removed from the index tree, or updated. */

1670

1667

 

1671

1668

                rec = btr_cur_get_rec(btr_cur);

1672

 

                node_index = dict_table_get_first_index(table);

1673

 

                offsets = rec_get_offsets(rec, node_index, offsets_,

 

1669

                index = dict_table_get_first_index(table);

 

1670

                offsets = rec_get_offsets(rec, index, offsets_,

1674

1671

                                          ULINT_UNDEFINED, &heap);

1675

1672

                change_ownership = btr_cur_mark_extern_inherited_fields(

1676

 

                        btr_cur_get_page_zip(btr_cur), rec, node_index, offsets,

 

1673

                        btr_cur_get_page_zip(btr_cur), rec, index, offsets,

1677

1674

                        node->update, mtr);

1678

1675

                if (referenced) {

1679

1676

                        /* NOTE that the following call loses

1680

1677

                        the position of pcur ! */

1681

1678

 

1682

1679

                        err = row_upd_check_references_constraints(

1683

 

                                node, pcur, table, node_index, offsets, thr, mtr);

 

1680

                                node, pcur, table, index, offsets, thr, mtr);

1684

1681

 

1685

1682

                        if (err != DB_SUCCESS) {

1686

1683

 

2154

2151

 

2155

2152

        trx_start_if_not_started(trx);

2156

2153

 

2157

 

        node = static_cast<upd_node_t *>(thr->run_node);

 

2154

        node = thr->run_node;

2158

2155

 

2159

2156

        sel_node = node->select;

2160

2157

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1