50
52
#define ROW_INS_NEXT 2
53
/*********************************************************************
54
This prototype is copied from /mysql/sql/ha_innodb.cc.
55
Invalidates the MySQL query cache for the table.
56
NOTE that the exact prototype of this function has to be in
57
/innobase/row/row0ins.c! */
60
innobase_invalidate_query_cache(
61
/*============================*/
62
trx_t* trx, /* in: transaction which modifies the table */
63
char* full_name, /* in: concatenation of database name, null
64
char '\0', table name, null char'\0';
65
NOTE that in Windows this is always
67
ulint full_name_len); /* in: full name length where also the null
70
/*************************************************************************
71
Creates an insert node struct. */
55
/*********************************************************************//**
56
Creates an insert node struct.
57
@return own: insert node struct */
76
/* out, own: insert node struct */
77
ulint ins_type, /* in: INS_VALUES, ... */
78
dict_table_t* table, /* in: table where to insert */
79
mem_heap_t* heap) /* in: mem heap where created */
62
ulint ins_type, /*!< in: INS_VALUES, ... */
63
dict_table_t* table, /*!< in: table where to insert */
64
mem_heap_t* heap) /*!< in: mem heap where created */
105
/***************************************************************
90
/***********************************************************//**
106
91
Creates an entry template for each index of a table. */
109
94
ins_node_create_entry_list(
110
95
/*=======================*/
111
ins_node_t* node) /* in: row insert node */
96
ins_node_t* node) /*!< in: row insert node */
113
98
dict_index_t* index;
131
/*********************************************************************
116
/*****************************************************************//**
132
117
Adds system field buffers to a row. */
135
120
row_ins_alloc_sys_fields(
136
121
/*=====================*/
137
ins_node_t* node) /* in: insert node */
122
ins_node_t* node) /*!< in: insert node */
140
125
dict_table_t* table;
183
168
dfield_set_data(dfield, ptr, DATA_ROLL_PTR_LEN);
186
/*************************************************************************
171
/*********************************************************************//**
187
172
Sets a new row to insert for an INS_DIRECT node. This function is only used
188
173
if we have constructed the row separately, which is a rare case; this
189
174
function is quite slow. */
192
177
ins_node_set_new_row(
193
178
/*=================*/
194
ins_node_t* node, /* in: insert node */
195
dtuple_t* row) /* in: new row (or first row) for the node */
179
ins_node_t* node, /*!< in: insert node */
180
dtuple_t* row) /*!< in: new row (or first row) for the node */
197
182
node->state = INS_NODE_SET_IX_LOCK;
198
183
node->index = NULL;
216
201
node->trx_id = ut_dulint_zero;
219
/***********************************************************************
204
/*******************************************************************//**
220
205
Does an insert operation by updating a delete-marked existing record
221
206
in the index. This situation can occur if the delete-marked record is
222
kept in the index for consistent reads. */
207
kept in the index for consistent reads.
208
@return DB_SUCCESS or error code */
225
211
row_ins_sec_index_entry_by_modify(
226
212
/*==============================*/
227
/* out: DB_SUCCESS or error code */
228
ulint mode, /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
213
ulint mode, /*!< in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
229
214
depending on whether mtr holds just a leaf
230
215
latch or also a tree latch */
231
btr_cur_t* cursor, /* in: B-tree cursor */
232
const dtuple_t* entry, /* in: index entry to insert */
233
que_thr_t* thr, /* in: query thread */
234
mtr_t* mtr) /* in: mtr; must be committed before
216
btr_cur_t* cursor, /*!< in: B-tree cursor */
217
const dtuple_t* entry, /*!< in: index entry to insert */
218
que_thr_t* thr, /*!< in: query thread */
219
mtr_t* mtr) /*!< in: mtr; must be committed before
235
220
latching any further pages */
237
222
big_rec_t* dummy_big_rec;
290
/***********************************************************************
275
/*******************************************************************//**
291
276
Does an insert operation by delete unmarking and updating a delete marked
292
277
existing record in the index. This situation can occur if the delete marked
293
record is kept in the index for consistent reads. */
278
record is kept in the index for consistent reads.
279
@return DB_SUCCESS, DB_FAIL, or error code */
296
282
row_ins_clust_index_entry_by_modify(
297
283
/*================================*/
298
/* out: DB_SUCCESS, DB_FAIL, or error code */
299
ulint mode, /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
284
ulint mode, /*!< in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
300
285
depending on whether mtr holds just a leaf
301
286
latch or also a tree latch */
302
btr_cur_t* cursor, /* in: B-tree cursor */
303
mem_heap_t** heap, /* in/out: pointer to memory heap, or NULL */
304
big_rec_t** big_rec,/* out: possible big rec vector of fields
287
btr_cur_t* cursor, /*!< in: B-tree cursor */
288
mem_heap_t** heap, /*!< in/out: pointer to memory heap, or NULL */
289
big_rec_t** big_rec,/*!< out: possible big rec vector of fields
305
290
which have to be stored externally by the
307
const dtuple_t* entry, /* in: index entry to insert */
308
que_thr_t* thr, /* in: query thread */
309
mtr_t* mtr) /* in: mtr; must be committed before
292
const dtuple_t* entry, /*!< in: index entry to insert */
293
que_thr_t* thr, /*!< in: query thread */
294
mtr_t* mtr) /*!< in: mtr; must be committed before
310
295
latching any further pages */
362
/*************************************************************************
347
/*********************************************************************//**
363
348
Returns TRUE if in a cascaded update/delete an ancestor node of node
364
updates (not DELETE, but UPDATE) table. */
349
updates (not DELETE, but UPDATE) table.
350
@return TRUE if an ancestor updates table */
367
353
row_ins_cascade_ancestor_updates_table(
368
354
/*===================================*/
369
/* out: TRUE if an ancestor updates table */
370
que_node_t* node, /* in: node in a query graph */
371
dict_table_t* table) /* in: table */
355
que_node_t* node, /*!< in: node in a query graph */
356
dict_table_t* table) /*!< in: table */
373
358
que_node_t* parent;
374
359
upd_node_t* upd_node;
395
/*************************************************************************
380
/*********************************************************************//**
396
381
Returns the number of ancestor UPDATE or DELETE nodes of a
397
cascaded update/delete node. */
382
cascaded update/delete node.
383
@return number of ancestors */
400
386
row_ins_cascade_n_ancestors(
401
387
/*========================*/
402
/* out: number of ancestors */
403
que_node_t* node) /* in: node in a query graph */
388
que_node_t* node) /*!< in: node in a query graph */
405
390
que_node_t* parent;
406
391
ulint n_ancestors = 0;
418
403
return(n_ancestors);
421
/**********************************************************************
406
/******************************************************************//**
422
407
Calculates the update vector node->cascade->update for a child table in
423
a cascaded update. */
409
@return number of fields in the calculated update vector; the value
410
can also be 0 if no foreign key fields changed; the returned value is
411
ULINT_UNDEFINED if the column type in the child table is too short to
412
fit the new value in the parent table: that means the update fails */
426
415
row_ins_cascade_calc_update_vec(
427
416
/*============================*/
428
/* out: number of fields in the
429
calculated update vector; the value
430
can also be 0 if no foreign key
431
fields changed; the returned value
432
is ULINT_UNDEFINED if the column
433
type in the child table is too short
434
to fit the new value in the parent
435
table: that means the update fails */
436
upd_node_t* node, /* in: update node of the parent
417
upd_node_t* node, /*!< in: update node of the parent
438
dict_foreign_t* foreign, /* in: foreign key constraint whose
419
dict_foreign_t* foreign, /*!< in: foreign key constraint whose
440
mem_heap_t* heap) /* in: memory heap to use as
421
mem_heap_t* heap) /*!< in: memory heap to use as
441
422
temporary storage */
443
424
upd_node_t* cascade = node->cascade_node;
606
587
return(n_fields_updated);
609
/*************************************************************************
590
/*********************************************************************//**
610
591
Set detailed error message associated with foreign key errors for
611
592
the given transaction. */
614
595
row_ins_set_detailed(
615
596
/*=================*/
616
trx_t* trx, /* in: transaction */
617
dict_foreign_t* foreign) /* in: foreign key constraint */
597
trx_t* trx, /*!< in: transaction */
598
dict_foreign_t* foreign) /*!< in: foreign key constraint */
619
600
mutex_enter(&srv_misc_tmpfile_mutex);
620
601
rewind(srv_misc_tmpfile);
632
613
mutex_exit(&srv_misc_tmpfile_mutex);
635
/*************************************************************************
616
/*********************************************************************//**
636
617
Reports a foreign key error associated with an update or a delete of a
637
618
parent table index entry. */
640
621
row_ins_foreign_report_err(
641
622
/*=======================*/
642
const char* errstr, /* in: error string from the viewpoint
623
const char* errstr, /*!< in: error string from the viewpoint
643
624
of the parent table */
644
que_thr_t* thr, /* in: query thread whose run_node
625
que_thr_t* thr, /*!< in: query thread whose run_node
645
626
is an update node */
646
dict_foreign_t* foreign, /* in: foreign key constraint */
647
const rec_t* rec, /* in: a matching index record in the
627
dict_foreign_t* foreign, /*!< in: foreign key constraint */
628
const rec_t* rec, /*!< in: a matching index record in the
649
const dtuple_t* entry) /* in: index entry in the parent
630
const dtuple_t* entry) /*!< in: index entry in the parent
652
633
FILE* ef = dict_foreign_err_file;
688
669
mutex_exit(&dict_foreign_err_mutex);
691
/*************************************************************************
672
/*********************************************************************//**
692
673
Reports a foreign key error to dict_foreign_err_file when we are trying
693
674
to add an index entry to a child table. Note that the adding may be the result
694
675
of an update, too. */
697
678
row_ins_foreign_report_add_err(
698
679
/*===========================*/
699
trx_t* trx, /* in: transaction */
700
dict_foreign_t* foreign, /* in: foreign key constraint */
701
const rec_t* rec, /* in: a record in the parent table:
680
trx_t* trx, /*!< in: transaction */
681
dict_foreign_t* foreign, /*!< in: foreign key constraint */
682
const rec_t* rec, /*!< in: a record in the parent table:
702
683
it does not match entry because we
703
684
have an error! */
704
const dtuple_t* entry) /* in: index entry to insert in the
685
const dtuple_t* entry) /*!< in: index entry to insert in the
707
688
FILE* ef = dict_foreign_err_file;
746
727
mutex_exit(&dict_foreign_err_mutex);
749
/*************************************************************************
730
/*********************************************************************//**
750
731
Invalidate the query cache for the given table. */
753
734
row_ins_invalidate_query_cache(
754
735
/*===========================*/
755
que_thr_t* thr, /* in: query thread whose run_node
736
que_thr_t* unused, /*!< in: query thread whose run_node
756
737
is an update node */
757
const char* name) /* in: table name prefixed with
738
const char* name) /*!< in: table name prefixed with
758
739
database name and a '/' character */
762
743
ulint len = strlen(name) + 1;
764
747
buf = mem_strdupl(name, len);
766
749
ptr = strchr(buf, '/');
770
/* We call a function in ha_innodb.cc */
771
#ifndef UNIV_HOTBACKUP
772
innobase_invalidate_query_cache(thr_get_trx(thr), buf, len);
777
/*************************************************************************
756
/*********************************************************************//**
778
757
Perform referential actions or checks when a parent row is deleted or updated
779
758
and the constraint had an ON DELETE or ON UPDATE condition which was not
760
@return DB_SUCCESS, DB_LOCK_WAIT, or error code */
783
763
row_ins_foreign_check_on_constraint(
784
764
/*================================*/
785
/* out: DB_SUCCESS, DB_LOCK_WAIT,
787
que_thr_t* thr, /* in: query thread whose run_node
765
que_thr_t* thr, /*!< in: query thread whose run_node
788
766
is an update node */
789
dict_foreign_t* foreign, /* in: foreign key constraint whose
767
dict_foreign_t* foreign, /*!< in: foreign key constraint whose
791
btr_pcur_t* pcur, /* in: cursor placed on a matching
769
btr_pcur_t* pcur, /*!< in: cursor placed on a matching
792
770
index record in the child table */
793
dtuple_t* entry, /* in: index entry in the parent
771
dtuple_t* entry, /*!< in: index entry in the parent
795
mtr_t* mtr) /* in: mtr holding the latch of pcur
773
mtr_t* mtr) /*!< in: mtr holding the latch of pcur
798
776
upd_node_t* node;
1144
/*************************************************************************
1122
/*********************************************************************//**
1145
1123
Sets a shared lock on a record. Used in locking possible duplicate key
1146
records and also in checking foreign key constraints. */
1124
records and also in checking foreign key constraints.
1125
@return DB_SUCCESS or error code */
1149
1128
row_ins_set_shared_rec_lock(
1150
1129
/*========================*/
1151
/* out: DB_SUCCESS or error code */
1152
ulint type, /* in: LOCK_ORDINARY, LOCK_GAP, or
1130
ulint type, /*!< in: LOCK_ORDINARY, LOCK_GAP, or
1153
1131
LOCK_REC_NOT_GAP type lock */
1154
const buf_block_t* block, /* in: buffer block of rec */
1155
const rec_t* rec, /* in: record */
1156
dict_index_t* index, /* in: index */
1157
const ulint* offsets,/* in: rec_get_offsets(rec, index) */
1158
que_thr_t* thr) /* in: query thread */
1132
const buf_block_t* block, /*!< in: buffer block of rec */
1133
const rec_t* rec, /*!< in: record */
1134
dict_index_t* index, /*!< in: index */
1135
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
1136
que_thr_t* thr) /*!< in: query thread */
1175
#ifndef UNIV_HOTBACKUP
1176
/*************************************************************************
1153
/*********************************************************************//**
1177
1154
Sets a exclusive lock on a record. Used in locking possible duplicate key
1156
@return DB_SUCCESS or error code */
1181
1159
row_ins_set_exclusive_rec_lock(
1182
1160
/*===========================*/
1183
/* out: DB_SUCCESS or error code */
1184
ulint type, /* in: LOCK_ORDINARY, LOCK_GAP, or
1161
ulint type, /*!< in: LOCK_ORDINARY, LOCK_GAP, or
1185
1162
LOCK_REC_NOT_GAP type lock */
1186
const buf_block_t* block, /* in: buffer block of rec */
1187
const rec_t* rec, /* in: record */
1188
dict_index_t* index, /* in: index */
1189
const ulint* offsets,/* in: rec_get_offsets(rec, index) */
1190
que_thr_t* thr) /* in: query thread */
1163
const buf_block_t* block, /*!< in: buffer block of rec */
1164
const rec_t* rec, /*!< in: record */
1165
dict_index_t* index, /*!< in: index */
1166
const ulint* offsets,/*!< in: rec_get_offsets(rec, index) */
1167
que_thr_t* thr) /*!< in: query thread */
1206
#endif /* !UNIV_HOTBACKUP */
1208
/*******************************************************************
1184
/***************************************************************//**
1209
1185
Checks if foreign key constraint fails for an index entry. Sets shared locks
1210
1186
which lock either the success or the failure of the constraint. NOTE that
1211
the caller must have a shared latch on dict_operation_lock. */
1187
the caller must have a shared latch on dict_operation_lock.
1188
@return DB_SUCCESS, DB_NO_REFERENCED_ROW, or DB_ROW_IS_REFERENCED */
1214
1191
row_ins_check_foreign_constraint(
1215
1192
/*=============================*/
1217
DB_NO_REFERENCED_ROW,
1218
or DB_ROW_IS_REFERENCED */
1219
ibool check_ref,/* in: TRUE if we want to check that
1193
ibool check_ref,/*!< in: TRUE if we want to check that
1220
1194
the referenced table is ok, FALSE if we
1221
1195
want to to check the foreign key table */
1222
dict_foreign_t* foreign,/* in: foreign constraint; NOTE that the
1196
dict_foreign_t* foreign,/*!< in: foreign constraint; NOTE that the
1223
1197
tables mentioned in it must be in the
1224
1198
dictionary cache if they exist at all */
1225
dict_table_t* table, /* in: if check_ref is TRUE, then the foreign
1199
dict_table_t* table, /*!< in: if check_ref is TRUE, then the foreign
1226
1200
table, else the referenced table */
1227
dtuple_t* entry, /* in: index entry for index */
1228
que_thr_t* thr) /* in: query thread */
1201
dtuple_t* entry, /*!< in: index entry for index */
1202
que_thr_t* thr) /*!< in: query thread */
1230
1204
upd_node_t* upd_node;
1231
1205
dict_table_t* check_table;
1532
/*******************************************************************
1506
/***************************************************************//**
1533
1507
Checks if foreign key constraints fail for an index entry. If index
1534
1508
is not mentioned in any constraint, this function does nothing,
1535
1509
Otherwise does searches to the indexes of referenced tables and
1536
1510
sets shared locks which lock either the success or the failure of
1512
@return DB_SUCCESS or error code */
1540
1515
row_ins_check_foreign_constraints(
1541
1516
/*==============================*/
1542
/* out: DB_SUCCESS or error code */
1543
dict_table_t* table, /* in: table */
1544
dict_index_t* index, /* in: index */
1545
dtuple_t* entry, /* in: index entry for index */
1546
que_thr_t* thr) /* in: query thread */
1517
dict_table_t* table, /*!< in: table */
1518
dict_index_t* index, /*!< in: index */
1519
dtuple_t* entry, /*!< in: index entry for index */
1520
que_thr_t* thr) /*!< in: query thread */
1548
1522
dict_foreign_t* foreign;
1611
1585
return(DB_SUCCESS);
1614
#ifndef UNIV_HOTBACKUP
1615
/*******************************************************************
1588
/***************************************************************//**
1616
1589
Checks if a unique key violation to rec would occur at the index entry
1591
@return TRUE if error */
1620
1594
row_ins_dupl_error_with_rec(
1621
1595
/*========================*/
1622
/* out: TRUE if error */
1623
const rec_t* rec, /* in: user record; NOTE that we assume
1596
const rec_t* rec, /*!< in: user record; NOTE that we assume
1624
1597
that the caller already has a record lock on
1626
const dtuple_t* entry, /* in: entry to insert */
1627
dict_index_t* index, /* in: index */
1628
const ulint* offsets)/* in: rec_get_offsets(rec, index) */
1599
const dtuple_t* entry, /*!< in: entry to insert */
1600
dict_index_t* index, /*!< in: index */
1601
const ulint* offsets)/*!< in: rec_get_offsets(rec, index) */
1630
1603
ulint matched_fields;
1631
1604
ulint matched_bytes;
1664
1637
return(!rec_get_deleted_flag(rec, rec_offs_comp(offsets)));
1666
#endif /* !UNIV_HOTBACKUP */
1668
/*******************************************************************
1640
/***************************************************************//**
1669
1641
Scans a unique non-clustered index at a given index entry to determine
1670
1642
whether a uniqueness violation has occurred for the key value of the entry.
1671
Set shared locks on possible duplicate records. */
1643
Set shared locks on possible duplicate records.
1644
@return DB_SUCCESS, DB_DUPLICATE_KEY, or DB_LOCK_WAIT */
1674
1647
row_ins_scan_sec_index_for_duplicate(
1675
1648
/*=================================*/
1676
/* out: DB_SUCCESS, DB_DUPLICATE_KEY, or
1678
dict_index_t* index, /* in: non-clustered unique index */
1679
dtuple_t* entry, /* in: index entry */
1680
que_thr_t* thr) /* in: query thread */
1649
dict_index_t* index, /*!< in: non-clustered unique index */
1650
dtuple_t* entry, /*!< in: index entry */
1651
que_thr_t* thr) /*!< in: query thread */
1682
#ifndef UNIV_HOTBACKUP
1683
1653
ulint n_unique;
1789
1759
dtuple_set_n_fields_cmp(entry, n_fields_cmp);
1792
#else /* UNIV_HOTBACKUP */
1793
/* This function depends on MySQL code that is not included in
1794
InnoDB Hot Backup builds. Besides, this function should never
1795
be called in InnoDB Hot Backup. */
1798
#endif /* UNIV_HOTBACKUP */
1801
/*******************************************************************
1764
/***************************************************************//**
1802
1765
Checks if a unique key violation error would occur at an index entry
1803
1766
insert. Sets shared locks on possible duplicate records. Works only
1804
for a clustered index! */
1767
for a clustered index!
1768
@return DB_SUCCESS if no error, DB_DUPLICATE_KEY if error,
1769
DB_LOCK_WAIT if we have to wait for a lock on a possible duplicate
1807
1773
row_ins_duplicate_error_in_clust(
1808
1774
/*=============================*/
1809
/* out: DB_SUCCESS if no error,
1810
DB_DUPLICATE_KEY if error, DB_LOCK_WAIT if we
1811
have to wait for a lock on a possible
1813
btr_cur_t* cursor, /* in: B-tree cursor */
1814
dtuple_t* entry, /* in: entry to insert */
1815
que_thr_t* thr, /* in: query thread */
1816
mtr_t* mtr) /* in: mtr */
1775
btr_cur_t* cursor, /*!< in: B-tree cursor */
1776
dtuple_t* entry, /*!< in: entry to insert */
1777
que_thr_t* thr, /*!< in: query thread */
1778
mtr_t* mtr) /*!< in: mtr */
1818
#ifndef UNIV_HOTBACKUP
1821
1782
ulint n_unique;
1939
1900
mem_heap_free(heap);
1942
#else /* UNIV_HOTBACKUP */
1943
/* This function depends on MySQL code that is not included in
1944
InnoDB Hot Backup builds. Besides, this function should never
1945
be called in InnoDB Hot Backup. */
1948
#endif /* UNIV_HOTBACKUP */
1951
/*******************************************************************
1905
/***************************************************************//**
1952
1906
Checks if an index entry has long enough common prefix with an existing
1953
1907
record so that the intended insert of the entry must be changed to a modify of
1954
1908
the existing record. In the case of a clustered index, the prefix must be
1955
1909
n_unique fields long, and in the case of a secondary index, all fields must be
1911
@return 0 if no update, ROW_INS_PREV if previous should be updated;
1912
currently we do the search so that only the low_match record can match
1913
enough to the search tuple, not the next record */
1959
1916
row_ins_must_modify(
1960
1917
/*================*/
1961
/* out: 0 if no update, ROW_INS_PREV if
1962
previous should be updated; currently we
1963
do the search so that only the low_match
1964
record can match enough to the search tuple,
1965
not the next record */
1966
btr_cur_t* cursor) /* in: B-tree cursor */
1918
btr_cur_t* cursor) /*!< in: B-tree cursor */
1968
1920
ulint enough_match;
1993
/*******************************************************************
1945
/***************************************************************//**
1994
1946
Tries to insert an index entry to an index. If the index is clustered
1995
1947
and a record with the same unique key is found, the other record is
1996
1948
necessarily marked deleted by a committed transaction, or a unique key
1998
1950
existing record, and we must write an undo log record on the delete
1999
1951
marked record. If the index is secondary, and a record with exactly the
2000
1952
same fields is found, the other record is necessarily marked deleted.
2001
It is then unmarked. Otherwise, the entry is just inserted to the index. */
1953
It is then unmarked. Otherwise, the entry is just inserted to the index.
1954
@return DB_SUCCESS, DB_LOCK_WAIT, DB_FAIL if pessimistic retry needed,
2004
1958
row_ins_index_entry_low(
2005
1959
/*====================*/
2006
/* out: DB_SUCCESS, DB_LOCK_WAIT, DB_FAIL
2007
if pessimistic retry needed, or error code */
2008
ulint mode, /* in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
1960
ulint mode, /*!< in: BTR_MODIFY_LEAF or BTR_MODIFY_TREE,
2009
1961
depending on whether we wish optimistic or
2010
1962
pessimistic descent down the index tree */
2011
dict_index_t* index, /* in: index */
2012
dtuple_t* entry, /* in: index entry to insert */
2013
ulint n_ext, /* in: number of externally stored columns */
2014
que_thr_t* thr) /* in: query thread */
1963
dict_index_t* index, /*!< in: index */
1964
dtuple_t* entry, /*!< in: index entry to insert */
1965
ulint n_ext, /*!< in: number of externally stored columns */
1966
que_thr_t* thr) /*!< in: query thread */
2016
1968
btr_cur_t cursor;
2017
1969
ulint ignore_sec_unique = 0;
2180
/*******************************************************************
2132
/***************************************************************//**
2181
2133
Inserts an index entry to index. Tries first optimistic, then pessimistic
2182
2134
descent down the tree. If the entry matches enough to a delete marked record,
2183
2135
performs the insert by updating or delete unmarking the delete marked
2137
@return DB_SUCCESS, DB_LOCK_WAIT, DB_DUPLICATE_KEY, or some other error code */
2187
2140
row_ins_index_entry(
2188
2141
/*================*/
2189
/* out: DB_SUCCESS, DB_LOCK_WAIT,
2190
DB_DUPLICATE_KEY, or some other error code */
2191
dict_index_t* index, /* in: index */
2192
dtuple_t* entry, /* in: index entry to insert */
2193
ulint n_ext, /* in: number of externally stored columns */
2194
ibool foreign,/* in: TRUE=check foreign key constraints */
2195
que_thr_t* thr) /* in: query thread */
2142
dict_index_t* index, /*!< in: index */
2143
dtuple_t* entry, /*!< in: index entry to insert */
2144
ulint n_ext, /*!< in: number of externally stored columns */
2145
ibool foreign,/*!< in: TRUE=check foreign key constraints */
2146
que_thr_t* thr) /*!< in: query thread */
2224
/***************************************************************
2175
/***********************************************************//**
2225
2176
Sets the values of the dtuple fields in entry from the values of appropriate
2226
2177
columns in row. */
2229
2180
row_ins_index_entry_set_vals(
2230
2181
/*=========================*/
2231
dict_index_t* index, /* in: index */
2232
dtuple_t* entry, /* in: index entry to make */
2233
const dtuple_t* row) /* in: row */
2182
dict_index_t* index, /*!< in: index */
2183
dtuple_t* entry, /*!< in: index entry to make */
2184
const dtuple_t* row) /*!< in: row */
2235
2186
ulint n_fields;
2276
/***************************************************************
2277
Inserts a single index entry to the table. */
2227
/***********************************************************//**
2228
Inserts a single index entry to the table.
2229
@return DB_SUCCESS if operation successfully completed, else error
2230
code or DB_LOCK_WAIT */
2280
2233
row_ins_index_entry_step(
2281
2234
/*=====================*/
2282
/* out: DB_SUCCESS if operation successfully
2283
completed, else error code or DB_LOCK_WAIT */
2284
ins_node_t* node, /* in: row insert node */
2285
que_thr_t* thr) /* in: query thread */
2235
ins_node_t* node, /*!< in: row insert node */
2236
que_thr_t* thr) /*!< in: query thread */
2300
/***************************************************************
2251
/***********************************************************//**
2301
2252
Allocates a row id for row and inits the node->index field. */
2304
2255
row_ins_alloc_row_id_step(
2305
2256
/*======================*/
2306
ins_node_t* node) /* in: row insert node */
2257
ins_node_t* node) /*!< in: row insert node */
2323
2274
dict_sys_write_row_id(node->row_id_buf, row_id);
2326
/***************************************************************
2277
/***********************************************************//**
2327
2278
Gets a row to insert from the values list. */
2330
2281
row_ins_get_row_from_values(
2331
2282
/*========================*/
2332
ins_node_t* node) /* in: row insert node */
2283
ins_node_t* node) /*!< in: row insert node */
2334
2285
que_node_t* list_node;
2335
2286
dfield_t* dfield;
2359
/***************************************************************
2310
/***********************************************************//**
2360
2311
Gets a row to insert from the select list. */
2363
2314
row_ins_get_row_from_select(
2364
2315
/*========================*/
2365
ins_node_t* node) /* in: row insert node */
2316
ins_node_t* node) /*!< in: row insert node */
2367
2318
que_node_t* list_node;
2368
2319
dfield_t* dfield;
2390
/***************************************************************
2391
Inserts a row to a table. */
2341
/***********************************************************//**
2342
Inserts a row to a table.
2343
@return DB_SUCCESS if operation successfully completed, else error
2344
code or DB_LOCK_WAIT */
2396
/* out: DB_SUCCESS if operation successfully
2397
completed, else error code or DB_LOCK_WAIT */
2398
ins_node_t* node, /* in: row insert node */
2399
que_thr_t* thr) /* in: query thread */
2349
ins_node_t* node, /*!< in: row insert node */
2350
que_thr_t* thr) /*!< in: query thread */
2442
2393
return(DB_SUCCESS);
2445
/***************************************************************
2396
/***********************************************************//**
2446
2397
Inserts a row to a table. This is a high-level function used in SQL execution
2399
@return query thread to run next or NULL */
2452
/* out: query thread to run next or NULL */
2453
que_thr_t* thr) /* in: query thread */
2404
que_thr_t* thr) /*!< in: query thread */
2455
2406
ins_node_t* node;
2456
2407
que_node_t* parent;
added
removed
plugin/innobase/row/row0ins.c
