← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/innobase/include/row0mysql.h

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/innobase/include/row0mysql.h
1
1
/*****************************************************************************
2
2
 
3
 
Copyright (c) 2000, 2009, Innobase Oy. All Rights Reserved.
 
3
Copyright (C) 2000, 2010, Innobase Oy. All Rights Reserved.
4
4
 
5
5
This program is free software; you can redistribute it and/or modify it under
6
6
the terms of the GNU General Public License as published by the Free Software
103
103
        ulint           col_len);       /*!< in: BLOB reference length
104
104
                                        (not BLOB length) */
105
105
/**************************************************************//**
 
106
Pad a column with spaces. */
 
107
UNIV_INTERN
 
108
void
 
109
row_mysql_pad_col(
 
110
/*==============*/
 
111
        ulint   mbminlen,       /*!< in: minimum size of a character,
 
112
                                in bytes */
 
113
        byte*   pad,            /*!< out: padded buffer */
 
114
        ulint   len);           /*!< in: number of bytes to pad */
 
115
 
 
116
/**************************************************************//**
106
117
Stores a non-SQL-NULL field given in the MySQL format in the InnoDB format.
107
118
The counterpart of this function is row_sel_field_store_in_mysql_format() in
108
119
row0sel.c.
253
264
/*==============================*/
254
265
        const dict_table_t*     table); /*!< in: table */
255
266
/*********************************************************************//**
256
 
Calculates the key number used inside MySQL for an Innobase index. We have
257
 
to take into account if we generated a default clustered index for the table
258
 
@return the key number used inside MySQL */
259
 
UNIV_INTERN
260
 
ulint
261
 
row_get_mysql_key_number_for_index(
262
 
/*===============================*/
263
 
        const dict_index_t*     index); /*!< in: index */
264
 
/*********************************************************************//**
265
267
Does an update or delete of a row for MySQL.
266
268
@return error code or DB_SUCCESS */
267
269
UNIV_INTERN
273
275
        row_prebuilt_t* prebuilt);      /*!< in: prebuilt struct in MySQL
274
276
                                        handle */
275
277
/*********************************************************************//**
276
 
This can only be used when srv_locks_unsafe_for_binlog is TRUE or
277
 
session is using a READ COMMITTED isolation level. Before
278
 
calling this function we must use trx_reset_new_rec_lock_info() and
279
 
trx_register_new_rec_lock() to store the information which new record locks
280
 
really were set. This function removes a newly set lock under prebuilt->pcur,
281
 
and also under prebuilt->clust_pcur. Currently, this is only used and tested
282
 
in the case of an UPDATE or a DELETE statement, where the row lock is of the
283
 
LOCK_X type.
284
 
Thus, this implements a 'mini-rollback' that releases the latest record
285
 
locks we set.
286
 
@return error code or DB_SUCCESS */
 
278
This can only be used when srv_locks_unsafe_for_binlog is TRUE or this
 
279
session is using a READ COMMITTED or READ UNCOMMITTED isolation level.
 
280
Before calling this function row_search_for_mysql() must have
 
281
initialized prebuilt->new_rec_locks to store the information which new
 
282
record locks really were set. This function removes a newly set
 
283
clustered index record lock under prebuilt->pcur or
 
284
prebuilt->clust_pcur.  Thus, this implements a 'mini-rollback' that
 
285
releases the latest clustered index record lock we set.
 
286
@return error code or DB_SUCCESS */
287
287
UNIV_INTERN
288
288
int
289
289
row_unlock_for_mysql(
290
290
/*=================*/
291
 
        row_prebuilt_t* prebuilt,       /*!< in: prebuilt struct in MySQL
 
291
        row_prebuilt_t* prebuilt,       /*!< in/out: prebuilt struct in MySQL
292
292
                                        handle */
293
 
        ibool           has_latches_on_recs);/*!< TRUE if called so that we have
294
 
                                        the latches on the records under pcur
295
 
                                        and clust_pcur, and we do not need to
296
 
                                        reposition the cursors. */
 
293
        ibool           has_latches_on_recs);/*!< in: TRUE if called
 
294
                                        so that we have the latches on
 
295
                                        the records under pcur and
 
296
                                        clust_pcur, and we do not need
 
297
                                        to reposition the cursors. */
297
298
/*********************************************************************//**
298
299
Creates an query graph node of 'update' type to be used in the MySQL
299
300
interface.
403
404
                                FOREIGN KEY (a, b) REFERENCES table2(c, d),
404
405
                                        table2 can be written also with the
405
406
                                        database name before it: test.table2 */
 
407
        size_t          sql_length,     /*!< in: length of sql_string */
406
408
        const char*     name,           /*!< in: table full name in the
407
409
                                        normalized form
408
410
                                        database_name/table_name */
451
453
        const char*     name,   /*!< in: table name */
452
454
        trx_t*          trx,    /*!< in: transaction handle */
453
455
        ibool           drop_db);/*!< in: TRUE=dropping whole database */
 
456
/*********************************************************************//**
 
457
Drop all temporary tables during crash recovery. */
 
458
UNIV_INTERN
 
459
void
 
460
row_mysql_drop_temp_tables(void);
 
461
/*============================*/
454
462
 
455
463
/*********************************************************************//**
456
464
Discards the tablespace of a table which stored in an .ibd file. Discarding
494
502
        trx_t*          trx,            /*!< in: transaction handle */
495
503
        ibool           commit);        /*!< in: if TRUE then commit trx */
496
504
/*********************************************************************//**
497
 
Checks a table for corruption.
498
 
@return DB_ERROR or DB_SUCCESS */
 
505
Checks that the index contains entries in an ascending order, unique
 
506
constraint is not broken, and calculates the number of index entries
 
507
in the read view of the current transaction.
 
508
@return DB_SUCCESS if ok */
499
509
UNIV_INTERN
500
510
ulint
501
 
row_check_table_for_mysql(
 
511
row_check_index_for_mysql(
502
512
/*======================*/
503
 
        row_prebuilt_t* prebuilt);      /*!< in: prebuilt struct in MySQL
504
 
                                        handle */
 
513
        row_prebuilt_t*         prebuilt,       /*!< in: prebuilt struct
 
514
                                                in MySQL handle */
 
515
        const dict_index_t*     index,          /*!< in: index */
 
516
        ulint*                  n_rows);        /*!< out: number of entries
 
517
                                                seen in the consistent read */
505
518
 
506
519
/*********************************************************************//**
507
520
Determines if a table is a magic monitor table.
525
538
                                        Innobase record in the current index;
526
539
                                        not defined if template_type is
527
540
                                        ROW_MYSQL_WHOLE_ROW */
 
541
        ulint   clust_rec_field_no;     /*!< field number of the column in an
 
542
                                        Innobase record in the clustered index;
 
543
                                        not defined if template_type is
 
544
                                        ROW_MYSQL_WHOLE_ROW */
528
545
        ulint   mysql_col_offset;       /*!< offset of the column in the MySQL
529
546
                                        row format */
530
547
        ulint   mysql_col_len;          /*!< length of the column in the MySQL
613
630
                                        the secondary index, then this is
614
631
                                        set to TRUE */
615
632
        unsigned        templ_contains_blob:1;/*!< TRUE if the template contains
616
 
                                        BLOB column(s) */
 
633
                                        a column with DATA_BLOB ==
 
634
                                        get_innobase_type_from_mysql_type();
 
635
                                        not to be confused with InnoDB
 
636
                                        externally stored columns
 
637
                                        (VARCHAR can be off-page too) */
617
638
        mysql_row_templ_t* mysql_template;/*!< template used to transform
618
639
                                        rows fast between MySQL and Innobase
619
640
                                        formats; memory for this template
692
713
        ulint           new_rec_locks;  /*!< normally 0; if
693
714
                                        srv_locks_unsafe_for_binlog is
694
715
                                        TRUE or session is using READ
695
 
                                        COMMITTED isolation level, in a
696
 
                                        cursor search, if we set a new
697
 
                                        record lock on an index, this is
698
 
                                        incremented; this is used in
699
 
                                        releasing the locks under the
700
 
                                        cursors if we are performing an
701
 
                                        UPDATE and we determine after
702
 
                                        retrieving the row that it does
703
 
                                        not need to be locked; thus,
704
 
                                        these can be used to implement a
705
 
                                        'mini-rollback' that releases
706
 
                                        the latest record locks */
 
716
                                        COMMITTED or READ UNCOMMITTED
 
717
                                        isolation level, set in
 
718
                                        row_search_for_mysql() if we set a new
 
719
                                        record lock on the secondary
 
720
                                        or clustered index; this is
 
721
                                        used in row_unlock_for_mysql()
 
722
                                        when releasing the lock under
 
723
                                        the cursor if we determine
 
724
                                        after retrieving the row that
 
725
                                        it does not need to be locked
 
726
                                        ('mini-rollback') */
707
727
        ulint           mysql_prefix_len;/*!< byte offset of the end of
708
728
                                        the last requested column */
709
729
        ulint           mysql_row_len;  /*!< length in bytes of a row in the