mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-18 04:53:01 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/sql/ha_isam.cc
unknown 32b28f9298 WL#1266 "Separate auto-set logic from TIMESTAMP type." 
Final version of patch.

Adds support for specifying of DEFAULT NOW() and/or ON UPDATE NOW()
clauses for TIMESTAMP field definition.
Current implementation allows only one such field per table and
uses several unireg types for storing info about this properties of
field. It should be replaced with better implementation when new
.frm format is introduced.


include/mysqld_error.h:
  Added error codes for case when we have more than one column with NOW()
  in DEFAULT or ON UPDATE clauses and for case when we are using ON UPDATE
  clause with wrong type.
mysql-test/r/create.result:
  Added tests for using of DEFAULT NOW() and ON UPDATE NOW() with
  non-TIMESTAMP fields.
mysql-test/r/show_check.result:
  Updated test results to reflect new default look of TIMESTAMP fields
  in SHOW CREATE TABLE.
mysql-test/r/system_mysql_db.result:
  Updated test results to reflect new default look of TIMESTAMP fields
  in SHOW CREATE TABLE.
mysql-test/r/type_ranges.result:
  Updated test results to reflect new default look of TIMESTAMP fields
  in SHOW COLUMNS.
mysql-test/r/type_timestamp.result:
  Added tests for various DEFAULT and ON UPDATE clauses for TIMESTAMP
  fields definitions.
mysql-test/t/create.test:
  Added tests for using of DEFAULT NOW() and ON UPDATE NOW() with
  non-TIMESTAMP fields.
mysql-test/t/type_timestamp.test:
  Added tests for various DEFAULT and ON UPDATE clauses for TIMESTAMP
  fields definitions.
sql/field.cc:
  Added support for various combinations of DEFAULT and ON UPDATE clauses
  for TIMESTAMP field. 
  
  Setting TABLE::timestamp* members for TIMESTAMP fields with auto-set 
  option taking into account their unireg type (which corresponds to 
  various DEFAULT/ON UPDATE values combinations). Replaced 
  TABLE::time_stamp with TABLE::timestamp_default_now/on_update_now
  couple moved their setup to separate method set_timestamp_offsets(),
  which now is called from  open_table instead of Field_timestamp cons.
sql/field.h:
  Added more unireg types for handling of DEFAULT NOW() and ON UPDATE
  NOW() for TIMESTAMP fields.
  Fixed value corresponding to DEFAULT item for TIMESTAMP field.
sql/ha_berkeley.cc:
  Now TIMESTAMP column with auto-set property could be updated during
  INSERT or/and UPDATE independently.
sql/ha_heap.cc:
  Now TIMESTAMP column with auto-set property could be updated during
  INSERT or/and UPDATE independently.
sql/ha_innodb.cc:
  Now TIMESTAMP column with auto-set property could be updated during
  INSERT or/and UPDATE independently.
sql/ha_isam.cc:
  Now TIMESTAMP column with auto-set property could be updated during
  INSERT or/and UPDATE independently.
sql/ha_isammrg.cc:
  Now TIMESTAMP column with auto-set property could be updated during
  INSERT or/and UPDATE independently.
sql/ha_myisam.cc:
  Now TIMESTAMP column with auto-set property could be updated during
  INSERT or/and UPDATE independently.
sql/ha_myisammrg.cc:
  Now TIMESTAMP column with auto-set property could be updated during
  INSERT or/and UPDATE independently.
sql/item_func.h:
  We need to distinguish NOW() from other function for using in 
  DEFAULT and in ON UPDATE clauses.
sql/item_timefunc.h:
  We need to distinguish NOW() from other function for using in 
  DEFAULT and in ON UPDATE clauses.
sql/mysql_priv.h:
  Added parameter for ON UPDATE value to add_field_to_list() function.
sql/share/czech/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/danish/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/dutch/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/english/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/estonian/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/french/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/german/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/greek/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/hungarian/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/italian/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/japanese/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/korean/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/norwegian-ny/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/norwegian/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/polish/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/portuguese/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/romanian/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/russian/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/serbian/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/slovak/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/spanish/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/swedish/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/share/ukrainian/errmsg.txt:
  Added error messages for case when we have more than one column with
  NOW() (CURRENT_TIMESTAMP is just more standard alias) in DEFAULT or 
  ON UPDATE clauses and for case when we are using ON UPDATE clause with
  wrong type.
sql/sql_base.cc:
  Added setup of TABLE::timestamp_default_now/on_update_now pair
  for each statement to open_table().
sql/sql_insert.cc:
  Using TABLE::timestamp_default_now/on_update_now pair instead of
  old TABLE::time_stamp. Added check for case then REPLACE could not
  be converted to UPDATE because of different DEFAULT/ON UPDATE values
  for TIMESTAMP field.
sql/sql_lex.h:
  Added member for value used in ON UPDATE clause to st_lex.
sql/sql_load.cc:
  Using TABLE::timestamp_default_now/on_update_now pair instead of
  old TABLE::time_stamp. We don't need to restore these members
  since they are set up for each statement in open_table().
sql/sql_parse.cc:
  Added handling of DEFAULT NOW() and ON UPDATE NOW() clauses for
  TIMESTAMP fields to add_field_to_list() function.
sql/sql_show.cc:
  Added support for DEFAULT CURRENT_TIMESTAMP (aka NOW() ) and 
  ON UPDATE CURRENT_TIMESTAMP to SHOW CREATE TABLE and SHOW COLUMNS.
sql/sql_table.cc:
  mysql_create_table() function - added check for number of TIMESTAMP 
    fields with auto-set values and replacing of old style TIMESTAMPs
    with their newer analogs.
  mysql_alter_table(): Using TABLE::timestamp_default_now/on_update_now 
    pair instead of old TABLE::time_stamp. We don't need to restore these
    members since they are set up for each statement in open_table().
sql/sql_update.cc:
  Left only setting of TABLE::timestamp_default_now/on_update_now
  to 0 since they should be already set up in open_table().
sql/sql_yacc.yy:
  Added support for DEFAULT NOW() and ON UPDATE NOW() in field
  definitions.
sql/table.h:
  Replaced TABLE::time_stamp withTABLE::timestamp_default_now/timestamp_on_update_now
  pair which allows to distinguish TIMESTAMP's with various DEFAULT/ON UPDATE
  clauses and optimize checks if TIMESTAMP field should be set to NOW()
  in handlers.
sql/unireg.cc:
  Now we are marking only TIMESTAMP fields with NOW() as default or
  as on update value as special field for unireg.
2004-04-02 10:12:53 +04:00

404 lines
12 KiB
C++
Raw Blame History

/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
#ifdef __GNUC__
#pragma implementation // gcc: Class implementation
#endif
#include "mysql_priv.h"
#ifdef HAVE_ISAM
#include <m_ctype.h>
#include <myisampack.h>
#include "ha_isam.h"
#ifndef MASTER
#include "../srclib/isam/isamdef.h"
#else
#include "../isam/isamdef.h"
#endif
/*****************************************************************************
** isam tables
*****************************************************************************/
const char **ha_isam::bas_ext() const
{ static const char *ext[]= { ".ISM",".ISD", NullS }; return ext; }
int ha_isam::open(const char *name, int mode, uint test_if_locked)
{
char name_buff[FN_REFLEN];
if (!(file=nisam_open(fn_format(name_buff,name,"","",2 | 4), mode,
test_if_locked)))
return (my_errno ? my_errno : -1);
if (!(test_if_locked == HA_OPEN_WAIT_IF_LOCKED ||
test_if_locked == HA_OPEN_ABORT_IF_LOCKED))
(void) nisam_extra(file,HA_EXTRA_NO_WAIT_LOCK);
info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
(void) nisam_extra(file,HA_EXTRA_WAIT_LOCK);
if (!table->db_record_offset)
int_table_flags|=HA_REC_NOT_IN_SEQ;
return (0);
}
int ha_isam::close(void)
{
return !nisam_close(file) ? 0 : my_errno ? my_errno : -1;
}
uint ha_isam::min_record_length(uint options) const
{
return (options & HA_OPTION_PACK_RECORD) ? 1 : 5;
}
int ha_isam::write_row(byte * buf)
{
statistic_increment(ha_write_count,&LOCK_status);
if (table->timestamp_default_now)
update_timestamp(buf+table->timestamp_default_now-1);
if (table->next_number_field && buf == table->record[0])
update_auto_increment();
return !nisam_write(file,buf) ? 0 : my_errno ? my_errno : -1;
}
int ha_isam::update_row(const byte * old_data, byte * new_data)
{
statistic_increment(ha_update_count,&LOCK_status);
if (table->timestamp_on_update_now)
update_timestamp(new_data+table->timestamp_on_update_now-1);
return !nisam_update(file,old_data,new_data) ? 0 : my_errno ? my_errno : -1;
}
int ha_isam::delete_row(const byte * buf)
{
statistic_increment(ha_delete_count,&LOCK_status);
return !nisam_delete(file,buf) ? 0 : my_errno ? my_errno : -1;
}
int ha_isam::index_read(byte * buf, const byte * key,
uint key_len, enum ha_rkey_function find_flag)
{
statistic_increment(ha_read_key_count,&LOCK_status);
int error=nisam_rkey(file, buf, active_index, key, key_len, find_flag);
table->status=error ? STATUS_NOT_FOUND: 0;
return !error ? 0 : my_errno ? my_errno : -1;
}
int ha_isam::index_read_idx(byte * buf, uint index, const byte * key,
uint key_len, enum ha_rkey_function find_flag)
{
statistic_increment(ha_read_key_count,&LOCK_status);
int error=nisam_rkey(file, buf, index, key, key_len, find_flag);
table->status=error ? STATUS_NOT_FOUND: 0;
return !error ? 0 : my_errno ? my_errno : -1;
}
int ha_isam::index_read_last(byte * buf, const byte * key, uint key_len)
{
statistic_increment(ha_read_key_count,&LOCK_status);
int error=nisam_rkey(file, buf, active_index, key, key_len,
HA_READ_PREFIX_LAST);
table->status=error ? STATUS_NOT_FOUND: 0;
return !error ? 0 : my_errno ? my_errno : -1;
}
int ha_isam::index_next(byte * buf)
{
statistic_increment(ha_read_next_count,&LOCK_status);
int error=nisam_rnext(file,buf,active_index);
table->status=error ? STATUS_NOT_FOUND: 0;
return !error ? 0 : my_errno ? my_errno : HA_ERR_END_OF_FILE;
}
int ha_isam::index_prev(byte * buf)
{
statistic_increment(ha_read_prev_count,&LOCK_status);
int error=nisam_rprev(file,buf, active_index);
table->status=error ? STATUS_NOT_FOUND: 0;
return !error ? 0 : my_errno ? my_errno : HA_ERR_END_OF_FILE;
}
int ha_isam::index_first(byte * buf)
{
statistic_increment(ha_read_first_count,&LOCK_status);
int error=nisam_rfirst(file, buf, active_index);
table->status=error ? STATUS_NOT_FOUND: 0;
return !error ? 0 : my_errno ? my_errno : HA_ERR_END_OF_FILE;
}
int ha_isam::index_last(byte * buf)
{
statistic_increment(ha_read_last_count,&LOCK_status);
int error=nisam_rlast(file, buf, active_index);
table->status=error ? STATUS_NOT_FOUND: 0;
return !error ? 0 : my_errno ? my_errno : HA_ERR_END_OF_FILE;
}
int ha_isam::rnd_init(bool scan)
{
return nisam_extra(file,HA_EXTRA_RESET) ? 0 : my_errno ? my_errno : -1;;
}
int ha_isam::rnd_next(byte *buf)
{
statistic_increment(ha_read_rnd_next_count,&LOCK_status);
int error=nisam_rrnd(file, buf, NI_POS_ERROR);
table->status=error ? STATUS_NOT_FOUND: 0;
return !error ? 0 : my_errno ? my_errno : -1;
}
int ha_isam::rnd_pos(byte * buf, byte *pos)
{
statistic_increment(ha_read_rnd_count,&LOCK_status);
int error=nisam_rrnd(file, buf, (ulong) ha_get_ptr(pos,ref_length));
table->status=error ? STATUS_NOT_FOUND: 0;
return !error ? 0 : my_errno ? my_errno : -1;
}
void ha_isam::position(const byte *record)
{
my_off_t position=nisam_position(file);
if (position == (my_off_t) ~ (ulong) 0)
position=HA_OFFSET_ERROR;
ha_store_ptr(ref, ref_length, position);
}
void ha_isam::info(uint flag)
{
N_ISAMINFO info;
(void) nisam_info(file,&info,flag);
if (flag & HA_STATUS_VARIABLE)
{
records = info.records;
deleted = info.deleted;
data_file_length=info.data_file_length;
index_file_length=info.index_file_length;
delete_length = info.delete_length;
check_time = info.isamchk_time;
mean_rec_length=info.mean_reclength;
}
if (flag & HA_STATUS_CONST)
{
max_data_file_length=info.max_data_file_length;
max_index_file_length=info.max_index_file_length;
create_time = info.create_time;
sortkey = info.sortkey;
block_size=nisam_block_size;
table->keys = min(table->keys,info.keys);
table->keys_in_use.set_prefix(table->keys);
table->db_options_in_use= info.options;
table->db_record_offset=
(table->db_options_in_use &
(HA_OPTION_PACK_RECORD | HA_OPTION_COMPRESS_RECORD)) ? 0 :
table->reclength;
if (!table->tmp_table)
{
ulong *rec_per_key=info.rec_per_key;
for (uint i=0 ; i < table->keys ; i++)
{
table->key_info[i].rec_per_key[table->key_info[i].key_parts-1]=
*(rec_per_key++);
}
}
ref_length=4;
}
if (flag & HA_STATUS_ERRKEY)
{
errkey = info.errkey;
ha_store_ptr(dupp_ref, ref_length, info.dupp_key_pos);
}
if (flag & HA_STATUS_TIME)
update_time = info.update_time;
}
int ha_isam::extra(enum ha_extra_function operation)
{
if ((specialflag & SPECIAL_SAFE_MODE || test_flags & TEST_NO_EXTRA) &&
(operation == HA_EXTRA_WRITE_CACHE ||
operation == HA_EXTRA_KEYREAD))
return 0;
return nisam_extra(file,operation);
}
int ha_isam::reset(void)
{
return nisam_extra(file,HA_EXTRA_RESET);
}
int ha_isam::external_lock(THD *thd, int lock_type)
{
if (!table->tmp_table)
return nisam_lock_database(file,lock_type);
return 0;
}
THR_LOCK_DATA **ha_isam::store_lock(THD *thd,
THR_LOCK_DATA **to,
enum thr_lock_type lock_type)
{
if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)
file->lock.type=lock_type;
*to++= &file->lock;
return to;
}
int ha_isam::create(const char *name, register TABLE *form,
HA_CREATE_INFO *create_info)
{
uint options=form->db_options_in_use;
int error;
uint i,j,recpos,minpos,fieldpos,temp_length,length;
enum ha_base_keytype type;
char buff[FN_REFLEN];
KEY *pos;
N_KEYDEF keydef[MAX_KEY];
N_RECINFO *recinfo,*recinfo_pos;
DBUG_ENTER("ha_isam::create");
type=HA_KEYTYPE_BINARY; // Keep compiler happy
if (!(recinfo= (N_RECINFO*) my_malloc((form->fields*2+2)*sizeof(N_RECINFO),
MYF(MY_WME))))
DBUG_RETURN(HA_ERR_OUT_OF_MEM);
pos=form->key_info;
for (i=0; i < form->keys ; i++, pos++)
{
keydef[i].base.flag= (pos->flags & HA_NOSAME);
for (j=0 ; (int7) j < pos->key_parts ; j++)
{
keydef[i].seg[j].base.flag=pos->key_part[j].key_part_flag;
Field *field=pos->key_part[j].field;
type=field->key_type();
if ((options & HA_OPTION_PACK_KEYS ||
(pos->flags & (HA_PACK_KEY | HA_BINARY_PACK_KEY |
HA_SPACE_PACK_USED))) &&
pos->key_part[j].length > 8 &&
(type == HA_KEYTYPE_TEXT ||
type == HA_KEYTYPE_NUM ||
(type == HA_KEYTYPE_BINARY && !field->zero_pack())))
{
if (j == 0)
keydef[i].base.flag|=HA_PACK_KEY;
if (!(field->flags & ZEROFILL_FLAG) &&
(field->type() == FIELD_TYPE_STRING ||
field->type() == FIELD_TYPE_VAR_STRING ||
((int) (pos->key_part[j].length - field->decimals()))
>= 4))
keydef[i].seg[j].base.flag|=HA_SPACE_PACK;
}
keydef[i].seg[j].base.type=(int) type;
keydef[i].seg[j].base.start= pos->key_part[j].offset;
keydef[i].seg[j].base.length= pos->key_part[j].length;
}
keydef[i].seg[j].base.type=(int) HA_KEYTYPE_END; /* End of key-parts */
}
recpos=0; recinfo_pos=recinfo;
while (recpos < (uint) form->reclength)
{
Field **field,*found=0;
minpos=form->reclength; length=0;
for (field=form->field ; *field ; field++)
{
if ((fieldpos=(*field)->offset()) >= recpos &&
fieldpos <= minpos)
{
/* skip null fields */
if (!(temp_length= (*field)->pack_length()))
continue; /* Skip null-fields */
if (! found || fieldpos < minpos ||
(fieldpos == minpos && temp_length < length))
{
minpos=fieldpos; found= *field; length=temp_length;
}
}
}
DBUG_PRINT("loop",("found: %lx recpos: %d minpos: %d length: %d",
found,recpos,minpos,length));
if (recpos != minpos)
{ // Reserved space (Null bits?)
recinfo_pos->base.type=(int) FIELD_NORMAL;
recinfo_pos++->base.length= (uint16) (minpos-recpos);
}
if (! found)
break;
if (found->flags & BLOB_FLAG)
{
/* ISAM can only handle blob pointers of sizeof(char(*)) */
recinfo_pos->base.type= (int) FIELD_BLOB;
if (options & HA_OPTION_LONG_BLOB_PTR)
length= length-portable_sizeof_char_ptr+sizeof(char*);
}
else if (!(options & HA_OPTION_PACK_RECORD))
recinfo_pos->base.type= (int) FIELD_NORMAL;
else if (found->zero_pack())
recinfo_pos->base.type= (int) FIELD_SKIP_ZERO;
else
recinfo_pos->base.type= (int) ((length <= 3 ||
(found->flags & ZEROFILL_FLAG)) ?
FIELD_NORMAL :
found->type() == FIELD_TYPE_STRING ||
found->type() == FIELD_TYPE_VAR_STRING ?
FIELD_SKIP_ENDSPACE :
FIELD_SKIP_PRESPACE);
recinfo_pos++ ->base.length=(uint16) length;
recpos=minpos+length;
DBUG_PRINT("loop",("length: %d type: %d",
recinfo_pos[-1].base.length,recinfo_pos[-1].base.type));
if ((found->flags & BLOB_FLAG) && (options & HA_OPTION_LONG_BLOB_PTR) &&
sizeof(char*) != portable_sizeof_char_ptr)
{ // Not used space
recinfo_pos->base.type=(int) FIELD_ZERO;
recinfo_pos++->base.length=
(uint16) (portable_sizeof_char_ptr-sizeof(char*));
recpos+= (portable_sizeof_char_ptr-sizeof(char*));
}
}
recinfo_pos->base.type= (int) FIELD_LAST; /* End of fieldinfo */
error=nisam_create(fn_format(buff,name,"","",2+4+16),form->keys,keydef,
recinfo,(ulong) form->max_rows, (ulong) form->min_rows,
0, 0, 0L);
my_free((gptr) recinfo,MYF(0));
DBUG_RETURN(error);
}
ha_rows ha_isam::records_in_range(int inx,
const byte *start_key,uint start_key_len,
enum ha_rkey_function start_search_flag,
const byte *end_key,uint end_key_len,
enum ha_rkey_function end_search_flag)
{
return (ha_rows) nisam_records_in_range(file,
inx,
start_key,start_key_len,
start_search_flag,
end_key,end_key_len,
end_search_flag);
}
#endif /* HAVE_ISAM */
Reference in a new issue View git blame Copy permalink