database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

Made keyread (key scanning) a key specific attribute.

Browse Source 
This avoids using fulltext keys for table scanning.
This also reverts Sinisa's original fix for this problem.


Docs/manual.texi:
  Update of SQL_JOIN_MAX_SIZE information3602
client/mysqldump.c:
  comment cleanup
include/my_aes.h:
  General cleanup for new file
include/rijndael.h:
  General cleanup for new file
include/sha1.h:
  General cleanup for new file
mysys/my_aes.c:
  General cleanup for new file
mysys/rijndael.c:
  General cleanup for new file
mysys/sha1.c:
  General cleanup for new file
sql/ha_berkeley.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_innodb.cc:
  Merge with 3.23.x
sql/ha_innodb.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_isam.cc:
  Moved things to table_flags()
sql/ha_isam.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_myisam.cc:
  Made keyread (key scanning) a key specific attribute.
sql/ha_myisam.h:
  Made keyread (key scanning) a key specific attribute.
sql/ha_myisammrg.h:
  Made keyread (key scanning) a key specific attribute.
sql/handler.h:
  Made keyread (key scanning) a key specific attribute.
sql/item_strfunc.cc:
  Cleanup of AES_xxx code
sql/opt_range.cc:
  Made keyread (key scanning) a key specific attribute.
sql/sql_base.cc:
  Made keyread (key scanning) a key specific attribute.
sql/sql_cache.cc:
  Removed compiler warning
sql/sql_select.cc:
  Removed wrong patch to fulltext problem
sql/table.cc:
  Made keyread (key scanning) a key specific attribute.
sql/table.h:
  Made keyread (key scanning) a key specific attribute.
This commit is contained in:
unknown
2002-06-19 00:22:30 +03:00
parent 9424f80f19
commit 518787c299
24 changed files with 1007 additions and 1120 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
Docs/manual.texi
View File

@ -27645,6 +27645,12 @@ flag again, the @code{SQL_MAX_JOIN_SIZE} variable will be ignored.
You can set a default value for this variable by starting @code{mysqld} with You can set a default value for this variable by starting @code{mysqld} with
@code{-O max_join_size=#}. @code{-O max_join_size=#}.
Note that if the result of the query is in the query cache, the above
check will not be made, but MySQL will instead send the result to the
client. We regard this as a feature as in this case the query result is
already computed and it will not cause any big burden for the server to
send the result to the client.
@item SQL_QUERY_CACHE_TYPE = OFF | ON | DEMAND @item SQL_QUERY_CACHE_TYPE = OFF | ON | DEMAND
@item SQL_QUERY_CACHE_TYPE = 0 | 1 | 2 @item SQL_QUERY_CACHE_TYPE = 0 | 1 | 2
Set query cache setting for this thread. Set query cache setting for this thread.

4
client/mysqldump.c
View File

@ -1438,8 +1438,8 @@ int main(int argc, char **argv)
else if (opt_single_transaction) /* Just to make it beautiful enough */ else if (opt_single_transaction) /* Just to make it beautiful enough */
{ {
/* /*
In case we were locking all tables, we did not start transaction In case we were locking all tables, we did not start transaction
so there is no need to commit it. so there is no need to commit it.
*/ */
/* This should just free locks as we did not change anything */ /* This should just free locks as we did not change anything */

76
include/my_aes.h
View File

@ -4,81 +4,63 @@
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* Header file for my_aes.c */ /* Header file for my_aes.c */
/* Wrapper to give simple interface for MySQL to AES standard encryption */ /* Wrapper to give simple interface for MySQL to AES standard encryption */
#ifndef __MY_AES_H
#define __MY_AES_H
#include "my_global.h"
#include <stdio.h>
#include "rijndael.h" #include "rijndael.h"
#define AES_KEY_LENGTH 128 C_MODE_START
/* Must be 128 192 or 256 */
#ifdef __cplusplus #define AES_KEY_LENGTH 128 /* Must be 128 192 or 256 */
extern "C" {
#endif
/* /*
my_aes_encrypt - Crypt buffer with AES encryption algorithm. my_aes_encrypt - Crypt buffer with AES encryption algorithm.
source - Pinter to data for encryption source - Pointer to data for encryption
source_length - size of encruption data source_length - size of encryption data
dest - buffer to place encrypted data (must be large enough) dest - buffer to place encrypted data (must be large enough)
key - Key to be used for encryption key - Key to be used for encryption
kel_length - Lenght of the key. Will handle keys of any length kel_length - Length of the key. Will handle keys of any length
returns - size of encrypted data, or negative in case of error.
returns - size of encrypted data, or negative in case of error.
*/ */
int my_aes_encrypt(const char* source, int source_length, const char* dest, int my_aes_encrypt(const char *source, int source_length, char *dest,
const char* key, int key_length); const char *key, int key_length);
/* /*
my_aes_decrypt - DeCrypt buffer with AES encryption algorithm. my_aes_decrypt - DeCrypt buffer with AES encryption algorithm.
source - Pinter to data for decryption source - Pointer to data for decryption
source_length - size of encrypted data source_length - size of encrypted data
dest - buffer to place decrypted data (must be large enough) dest - buffer to place decrypted data (must be large enough)
key - Key to be used for decryption key - Key to be used for decryption
kel_length - Lenght of the key. Will handle keys of any length kel_length - Length of the key. Will handle keys of any length
returns - size of original data, or negative in case of error.
returns - size of original data, or negative in case of error.
*/ */
int my_aes_decrypt(const char* source, int source_length, const char* dest, int my_aes_decrypt(const char *source, int source_length, char *dest,
const char* key, int key_length); const char *key, int key_length);
/* /*
my_aes_get_size - get size of buffer which will be large enough for encrypted my_aes_get_size - get size of buffer which will be large enough for encrypted
data data
source_length - length of data to be encrypted source_length - length of data to be encrypted
returns - size of buffer required to store encrypted data
returns - size of buffer required to store encrypted data
*/ */
int my_aes_get_size(int source_length); int my_aes_get_size(int source_length);
C_MODE_END
#ifdef __cplusplus
}
#endif
#endif

50
include/rijndael.h
View File

@ -4,45 +4,39 @@
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* /*
rijndael-alg-fst.h rijndael-alg-fst.h
@version 3.0 (December 2000) @version 3.0 (December 2000)
Optimised ANSI C code for the Rijndael cipher (now AES) Optimised ANSI C code for the Rijndael cipher (now AES)
@author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be> @author Vincent Rijmen <vincent.rijmen@esat.kuleuven.ac.be>
@author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be> @author Antoon Bosselaers <antoon.bosselaers@esat.kuleuven.ac.be>
@author Paulo Barreto <paulo.barreto@terra.com.br> @author Paulo Barreto <paulo.barreto@terra.com.br>
This code is hereby placed in the public domain. This code is hereby placed in the public domain.
Modified by Peter Zaitsev to fit MySQL coding style.
Modified by Peter Zaitsev to fit MySQL coding style.
*/ */
#ifndef __RIJNDAEL_ALG_FST_H
#define __RIJNDAEL_ALG_FST_H
#define MAXKC (256/32) #define AES_MAXKC (256/32)
#define MAXKB (256/8) #define AES_MAXKB (256/8)
#define MAXNR 14 #define AES_MAXNR 14
int rijndaelKeySetupEnc(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[], int rijndaelKeySetupEnc(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[],
int keyBits); int keyBits);
int rijndaelKeySetupDec(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[], int rijndaelKeySetupDec(uint32 rk[/*4*(Nr + 1)*/], const uint8 cipherKey[],
int keyBits); int keyBits);
void rijndaelEncrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr, void rijndaelEncrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr,
const uint8 pt[16], uint8 ct[16]); const uint8 pt[16], uint8 ct[16]);
void rijndaelDecrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr, void rijndaelDecrypt(const uint32 rk[/*4*(Nr + 1)*/], int Nr,
const uint8 ct[16], uint8 pt[16]); const uint8 ct[16], uint8 pt[16]);
#endif /* __RIJNDAEL_ALG_FST_H */

79
include/sha1.h
View File

@ -4,81 +4,64 @@
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* /*
sha1.h This is the header file for code which implements the Secure
Hashing Algorithm 1 as defined in FIPS PUB 180-1 published
Description: April 17, 1995.
This is the header file for code which implements the Secure
Hashing Algorithm 1 as defined in FIPS PUB 180-1 published Many of the variable names in this code, especially the
April 17, 1995. single character names, were used because those were the names
used in the publication.
Many of the variable names in this code, especially the
single character names, were used because those were the names Please read the file sha1.c for more information.
used in the publication.
Modified 2002 by Peter Zaitsev to better follow MySQL standards
Please read the file sha1.c for more information.
*/ */
/* Modified 2002 by Peter Zaitsev to better follow MySQL standards */
#ifndef _SHA1_H_
#define _SHA1_H_
#include "my_global.h"
/* Required for uint32, uint8, int16 ulonglong types */
enum sha_result_codes enum sha_result_codes
{ {
SHA_SUCCESS = 0, SHA_SUCCESS = 0,
SHA_NULL, /* Null pointer parameter */ SHA_NULL, /* Null pointer parameter */
SHA_INPUT_TOO_LONG, /* input data too long */ SHA_INPUT_TOO_LONG, /* input data too long */
SHA_STATE_ERROR /* called Input after Result */ SHA_STATE_ERROR /* called Input after Result */
}; };
#define SHA1_HASH_SIZE 20 /* Hash size in bytes */ #define SHA1_HASH_SIZE 20 /* Hash size in bytes */
/* /*
This structure will hold context information for the SHA-1 This structure will hold context information for the SHA-1
hashing operation hashing operation
*/ */
typedef struct SHA1_CONTEXT typedef struct SHA1_CONTEXT
{ {
ulonglong Length; /* Message length in bits */ ulonglong Length; /* Message length in bits */
uint32 Intermediate_Hash[SHA1_HASH_SIZE/4]; /* Message Digest */ uint32 Intermediate_Hash[SHA1_HASH_SIZE/4]; /* Message Digest */
int Computed; /* Is the digest computed? */ int Computed; /* Is the digest computed? */
int Corrupted; /* Is the message digest corrupted? */ int Corrupted; /* Is the message digest corrupted? */
int16 Message_Block_Index; /* Index into message block array */ int16 Message_Block_Index; /* Index into message block array */
uint8 Message_Block[64]; /* 512-bit message blocks */ uint8 Message_Block[64]; /* 512-bit message blocks */
} SHA1_CONTEXT; } SHA1_CONTEXT;
/* /*
* Function Prototypes Function Prototypes
*/ */
#ifdef __cplusplus C_MODE_START
extern "C" {
#endif
int sha1_reset( SHA1_CONTEXT* ); int sha1_reset( SHA1_CONTEXT* );
int sha1_input( SHA1_CONTEXT*, const uint8 *, unsigned int ); int sha1_input( SHA1_CONTEXT*, const uint8 *, unsigned int );
int sha1_result( SHA1_CONTEXT* , uint8 Message_Digest[SHA1_HASH_SIZE] ); int sha1_result( SHA1_CONTEXT* , uint8 Message_Digest[SHA1_HASH_SIZE] );
#ifdef __cplusplus
}
#endif
#endif C_MODE_END

212
mysys/my_aes.c
View File

@ -4,184 +4,196 @@
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* /*
Implementation of AES Encryption for MySQL Implementation of AES Encryption for MySQL
Initial version by Peter Zaitsev June 2002 Initial version by Peter Zaitsev June 2002
*/ */
#include "my_global.h" #include <my_global.h>
#include "m_string.h" #include <m_string.h>
#include "my_aes.h" #include "my_aes.h"
enum encrypt_dir { AES_ENCRYPT, AES_DECRYPT }; enum encrypt_dir { AES_ENCRYPT, AES_DECRYPT };
#define AES_BLOCK_SIZE 16 #define AES_BLOCK_SIZE 16 /* Block size in bytes */
/* Block size in bytes */
#define AES_BAD_DATA -1
/* If bad data discovered during decoding */
/* The structure for key information */ #define AES_BAD_DATA -1 /* If bad data discovered during decoding */
/* The structure for key information */
typedef struct { typedef struct {
int nr; /* Number of rounds */ int nr; /* Number of rounds */
uint32 rk[4*(MAXNR + 1)]; /* key schedule */ uint32 rk[4*(AES_MAXNR + 1)]; /* key schedule */
} KEYINSTANCE; } KEYINSTANCE;
/* /*
This is internal function just keeps joint code of Key generation This is internal function just keeps joint code of Key generation
rkey - Address of Key Instance to be created
direction - Direction (are we encoding or decoding) SYNOPSIS
key - key to use for real key creation my_aes_create_key()
key_length - length of the key aes_key Address of Key Instance to be created
direction Direction (are we encoding or decoding)
returns - returns 0 on success and negative on error key Key to use for real key creation
*/ key_length Length of the key
static int my_aes_create_key(KEYINSTANCE* aes_key,char direction, char* key,
int key_length) DESCRIPTION
{
char rkey[AES_KEY_LENGTH/8]; /* The real key to be used for encryption */ RESULT
char *ptr; /* Start of the real key*/ 0 ok
-1 Error Note: The current impementation never returns this
*/
static int my_aes_create_key(KEYINSTANCE *aes_key,
enum encrypt_dir direction, const char *key,
int key_length)
{
char rkey[AES_KEY_LENGTH/8]; /* The real key to be used for encryption */
char *rkey_end=rkey+AES_KEY_LENGTH/8; /* Real key boundary */ char *rkey_end=rkey+AES_KEY_LENGTH/8; /* Real key boundary */
char *sptr; /* Start of the working key */ char *ptr; /* Start of the real key*/
char *key_end=key+key_length; /* Working key boundary*/ const char *sptr; /* Start of the working key */
const char *key_end=key+key_length; /* Working key boundary*/
bzero(rkey,AES_KEY_LENGTH/8); /* Set initial key */ bzero(rkey,AES_KEY_LENGTH/8); /* Set initial key */
for (ptr= rkey, sptr= key; sptr < key_end; ptr++,sptr++) for (ptr= rkey, sptr= key; sptr < key_end; ptr++,sptr++)
{ {
if (ptr == rkey_end) if (ptr == rkey_end)
ptr= rkey; /* Just loop over tmp_key until we used all key */ ptr= rkey; /* Just loop over tmp_key until we used all key */
*ptr^= *sptr; *ptr^= *sptr;
} }
if (direction==AES_DECRYPT) if (direction == AES_DECRYPT)
aes_key->nr = rijndaelKeySetupDec(aes_key->rk, rkey, AES_KEY_LENGTH); aes_key->nr = rijndaelKeySetupDec(aes_key->rk, rkey, AES_KEY_LENGTH);
else else
aes_key->nr = rijndaelKeySetupEnc(aes_key->rk, rkey, AES_KEY_LENGTH); aes_key->nr = rijndaelKeySetupEnc(aes_key->rk, rkey, AES_KEY_LENGTH);
return 0; return 0;
} }
/* /*
my_aes_encrypt - Crypt buffer with AES encryption algorithm. Crypt buffer with AES encryption algorithm.
source - Pinter to data for encryption
source_length - size of encruption data
dest - buffer to place encrypted data (must be large enough)
key - Key to be used for encryption
kel_length - Lenght of the key. Will handle keys of any length
returns - size of encrypted data, or negative in case of error. SYNOPSIS
my_aes_encrypt()
source Pointer to data for encryption
source_length Size of encryption data
dest Buffer to place encrypted data (must be large enough)
key Key to be used for encryption
key_length Length of the key. Will handle keys of any length
RETURN
>= 0 Size of encrypted data
< 0 Error
*/ */
int my_aes_encrypt(const char* source, int source_length, const char* dest, int my_aes_encrypt(const char* source, int source_length, char* dest,
const char* key, int key_length) const char* key, int key_length)
{ {
KEYINSTANCE aes_key; KEYINSTANCE aes_key;
char block[AES_BLOCK_SIZE]; /* 128 bit block used for padding */ char block[AES_BLOCK_SIZE]; /* 128 bit block used for padding */
int rc; /* result codes */ int rc; /* result codes */
int num_blocks; /* number of complete blocks */ int num_blocks; /* number of complete blocks */
char pad_len; /* pad size for the last block */ char pad_len; /* pad size for the last block */
int i; int i;
if ((rc=my_aes_create_key(&aes_key,AES_ENCRYPT,key,key_length))) if ((rc= my_aes_create_key(&aes_key,AES_ENCRYPT,key,key_length)))
return rc; return rc;
num_blocks = source_length/AES_BLOCK_SIZE; num_blocks = source_length/AES_BLOCK_SIZE;
for (i = num_blocks; i > 0; i--) /* Encode complete blocks */ for (i = num_blocks; i > 0; i--) /* Encode complete blocks */
{ {
rijndaelEncrypt(aes_key.rk, aes_key.nr, source, dest); rijndaelEncrypt(aes_key.rk, aes_key.nr, source, dest);
source+= AES_BLOCK_SIZE; source+= AES_BLOCK_SIZE;
dest+= AES_BLOCK_SIZE; dest+= AES_BLOCK_SIZE;
} }
/* Encode the rest. We always have incomplete block */ /* Encode the rest. We always have incomplete block */
pad_len = AES_BLOCK_SIZE - (source_length - AES_BLOCK_SIZE*num_blocks); pad_len = AES_BLOCK_SIZE - (source_length - AES_BLOCK_SIZE*num_blocks);
memcpy(block, source, 16 - pad_len); memcpy(block, source, 16 - pad_len);
bfill(block + AES_BLOCK_SIZE - pad_len, pad_len, pad_len); bfill(block + AES_BLOCK_SIZE - pad_len, pad_len, pad_len);
rijndaelEncrypt(aes_key.rk, aes_key.nr, block, dest); rijndaelEncrypt(aes_key.rk, aes_key.nr, block, dest);
return AES_BLOCK_SIZE*(num_blocks + 1); return AES_BLOCK_SIZE*(num_blocks + 1);
} }
/* /*
my_aes_decrypt - DeCrypt buffer with AES encryption algorithm. DeCrypt buffer with AES encryption algorithm.
source - Pinter to data for decryption
source_length - size of encrypted data
dest - buffer to place decrypted data (must be large enough)
key - Key to be used for decryption
kel_length - Lenght of the key. Will handle keys of any length
returns - size of original data, or negative in case of error. SYNOPSIS
my_aes_decrypt()
source Pointer to data for decryption
source_length Size of encrypted data
dest Buffer to place decrypted data (must be large enough)
key Key to be used for decryption
key_length Length of the key. Will handle keys of any length
*/ RETURN
>= 0 Size of encrypted data
< 0 Error
*/
int my_aes_decrypt(const char* source, int source_length, const char* dest, int my_aes_decrypt(const char *source, int source_length, char *dest,
const char* key, int key_length) const char *key, int key_length)
{ {
KEYINSTANCE aes_key; KEYINSTANCE aes_key;
char block[AES_BLOCK_SIZE]; /* 128 bit block used for padding */ char block[AES_BLOCK_SIZE]; /* 128 bit block used for padding */
int rc; /* result codes */ int rc; /* Result codes */
int num_blocks; /* number of complete blocks */ int num_blocks; /* Number of complete blocks */
char pad_len; /* pad size for the last block */ char pad_len; /* Pad size for the last block */
int i; int i;
if ((rc=my_aes_create_key(&aes_key,AES_DECRYPT,key,key_length))) if ((rc=my_aes_create_key(&aes_key,AES_DECRYPT,key,key_length)))
return rc; return rc;
num_blocks = source_length/AES_BLOCK_SIZE;
num_blocks = source_length/AES_BLOCK_SIZE;
if ( (source_length!=num_blocks*AES_BLOCK_SIZE) || num_blocks==0)
return AES_BAD_DATA; /* Input size has to be even and at leas one block */ if ((source_length != num_blocks*AES_BLOCK_SIZE) || num_blocks ==0 )
return AES_BAD_DATA; /* Input size has to be even and at least one block */
for (i = num_blocks-1; i > 0; i--) /* Decode all but last blocks */ for (i = num_blocks-1; i > 0; i--) /* Decode all but last blocks */
{ {
rijndaelDecrypt(aes_key.rk, aes_key.nr, source, dest); rijndaelDecrypt(aes_key.rk, aes_key.nr, source, dest);
source+= AES_BLOCK_SIZE; source+= AES_BLOCK_SIZE;
dest+= AES_BLOCK_SIZE; dest+= AES_BLOCK_SIZE;
} }
rijndaelDecrypt(aes_key.rk, aes_key.nr, source, block);
pad_len = block[AES_BLOCK_SIZE-1]; /* Just use last char in the block as size*/
if (pad_len > AES_BLOCK_SIZE) rijndaelDecrypt(aes_key.rk, aes_key.nr, source, block);
pad_len = block[AES_BLOCK_SIZE-1]; /* Use last char in the block as size */
if (pad_len > AES_BLOCK_SIZE)
return AES_BAD_DATA; return AES_BAD_DATA;
/* We could also check whole padding but we do not really need this */ /* We could also check whole padding but we do not really need this */
memcpy(dest, block, AES_BLOCK_SIZE - pad_len); memcpy(dest, block, AES_BLOCK_SIZE - pad_len);
return AES_BLOCK_SIZE*num_blocks - pad_len;
return AES_BLOCK_SIZE*num_blocks - pad_len;
} }
/* /*
my_aes_get_size - get size of buffer which will be large enough for encrypted Get size of buffer which will be large enough for encrypted data
data
source_length - length of data to be encrypted SYNOPSIS
returns - size of buffer required to store encrypted data my_aes_get_size()
source_length Length of data to be encrypted
RETURN
Size of buffer required to store encrypted data
*/ */
int my_aes_get_size(int source_length) int my_aes_get_size(int source_length)
{ {
return AES_BLOCK_SIZE*(source_length/AES_BLOCK_SIZE)+AES_BLOCK_SIZE; return AES_BLOCK_SIZE*(source_length/AES_BLOCK_SIZE)+AES_BLOCK_SIZE;
} }

1152
mysys/rijndael.c
View File

File diff suppressed because it is too large Load Diff

390
mysys/sha1.c
View File

@ -4,54 +4,49 @@
it under the terms of the GNU General Public License as published by it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or the Free Software Foundation; either version 2 of the License, or
(at your option) any later version. (at your option) any later version.
This program is distributed in the hope that it will be useful, This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details. GNU General Public License for more details.
You should have received a copy of the GNU General Public License You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA */
/* /*
sha1.c Original Source from: http://www.faqs.org/rfcs/rfc3174.html
Original Source from: http://www.faqs.org/rfcs/rfc3174.html
DESCRIPTION
Description: This file implements the Secure Hashing Algorithm 1 as
This file implements the Secure Hashing Algorithm 1 as defined in FIPS PUB 180-1 published April 17, 1995.
defined in FIPS PUB 180-1 published April 17, 1995.
The SHA-1, produces a 160-bit message digest for a given data
The SHA-1, produces a 160-bit message digest for a given stream. It should take about 2**n steps to find a message with the
data stream. It should take about 2**n steps to find a same digest as a given message and 2**(n/2) to find any two
message with the same digest as a given message and messages with the same digest, when n is the digest size in bits.
2**(n/2) to find any two messages with the same digest, Therefore, this algorithm can serve as a means of providing a
when n is the digest size in bits. Therefore, this "fingerprint" for a message.
algorithm can serve as a means of providing a
"fingerprint" for a message. PORTABILITY ISSUES
SHA-1 is defined in terms of 32-bit "words". This code uses
Portability Issues: <stdint.h> (included via "sha1.h" to define 32 and 8 bit unsigned
SHA-1 is defined in terms of 32-bit "words". This code integer types. If your C compiler does not support 32 bit unsigned
uses <stdint.h> (included via "sha1.h" to define 32 and 8 integers, this code is not appropriate.
bit unsigned integer types. If your C compiler does not
support 32 bit unsigned integers, this code is not CAVEATS
appropriate. SHA-1 is designed to work with messages less than 2^64 bits long.
Although SHA-1 allows a message digest to be generated for messages
Caveats: of any number of bits less than 2^64, this implementation only
SHA-1 is designed to work with messages less than 2^64 bits works with messages with a length that is a multiple of the size of
long. Although SHA-1 allows a message digest to be generated an 8-bit character.
for messages of any number of bits less than 2^64, this
implementation only works with messages with a length that is CHANGES
a multiple of the size of an 8-bit character. 2002 by Peter Zaitsev to
- fit to new prototypes according to MySQL standard
*/ - Some optimizations
- All checking is now done in debug only mode
/* - More comments
Modified 2002 by Peter Zaitsev to
- fit to new prototypes according to MySQL standard
- Some optimizations
- All checking is now done in debug only mode
- More comments
*/ */
#include "my_global.h" #include "my_global.h"
@ -59,32 +54,33 @@
#include "sha1.h" #include "sha1.h"
/* /*
Define the SHA1 circular left shift macro Define the SHA1 circular left shift macro
*/ */
#define SHA1CircularShift(bits,word) \ #define SHA1CircularShift(bits,word) \
(((word) << (bits)) | ((word) >> (32-(bits)))) (((word) << (bits)) | ((word) >> (32-(bits))))
/* Local Function Prototyptes */ /* Local Function Prototyptes */
void SHA1PadMessage(SHA1_CONTEXT*); static void SHA1PadMessage(SHA1_CONTEXT*);
void SHA1ProcessMessageBlock(SHA1_CONTEXT*); static void SHA1ProcessMessageBlock(SHA1_CONTEXT*);
/* /*
sha1_reset Initialize SHA1Context
Description: SYNOPSIS
This function will initialize the SHA1Context in preparation sha1_reset()
for computing a new SHA1 message digest. context [in/out] The context to reset.
Parameters: DESCRIPTION
context: [in/out] This function will initialize the SHA1Context in preparation
The context to reset. for computing a new SHA1 message digest.
Returns: RETURN
sha Error Code. SHA_SUCCESS ok
!= SHA_SUCCESS sha Error Code.
*/ */
const uint32 sha_const_key[5]= const uint32 sha_const_key[5]=
{ {
@ -98,17 +94,14 @@ const uint32 sha_const_key[5]=
int sha1_reset(SHA1_CONTEXT *context) int sha1_reset(SHA1_CONTEXT *context)
{ {
#ifndef DBUG_OFF
#ifndef DBUG_OFF
if (!context) if (!context)
{
return SHA_NULL; return SHA_NULL;
} #endif
#endif
context->Length = 0;
context->Message_Block_Index = 0;
context->Length = 0;
context->Message_Block_Index = 0;
context->Intermediate_Hash[0] = sha_const_key[0]; context->Intermediate_Hash[0] = sha_const_key[0];
context->Intermediate_Hash[1] = sha_const_key[1]; context->Intermediate_Hash[1] = sha_const_key[1];
context->Intermediate_Hash[2] = sha_const_key[2]; context->Intermediate_Hash[2] = sha_const_key[2];
@ -121,165 +114,124 @@ int sha1_reset(SHA1_CONTEXT *context)
return SHA_SUCCESS; return SHA_SUCCESS;
} }
/* /*
sha1_result Return the 160-bit message digest into the array provided by the caller
Description: SYNOPSIS
This function will return the 160-bit message digest into the sha1_result()
Message_Digest array provided by the caller. context [in/out] The context to use to calculate the SHA-1 hash.
NOTE: The first octet of hash is stored in the 0th element, Message_Digest: [out] Where the digest is returned.
the last octet of hash in the 19th element.
DESCRIPTION
Parameters: NOTE: The first octet of hash is stored in the 0th element,
context: [in/out] the last octet of hash in the 19th element.
The context to use to calculate the SHA-1 hash.
Message_Digest: [out] RETURN
Where the digest is returned. SHA_SUCCESS ok
!= SHA_SUCCESS sha Error Code.
Returns:
sha Error Code.
*/ */
int sha1_result( SHA1_CONTEXT *context, int sha1_result(SHA1_CONTEXT *context,
uint8 Message_Digest[SHA1_HASH_SIZE]) uint8 Message_Digest[SHA1_HASH_SIZE])
{ {
int i; int i;
#ifndef DBUG_OFF #ifndef DBUG_OFF
if (!context || !Message_Digest) if (!context || !Message_Digest)
{
return SHA_NULL; return SHA_NULL;
}
if (context->Corrupted) if (context->Corrupted)
{
return context->Corrupted; return context->Corrupted;
} #endif
if (!context->Computed) if (!context->Computed)
{ {
#endif
SHA1PadMessage(context); SHA1PadMessage(context);
/* message may be sensitive, clear it out */ /* message may be sensitive, clear it out */
bzero((char*) context->Message_Block,64); bzero((char*) context->Message_Block,64);
context->Length = 0; /* and clear length */ context->Length = 0; /* and clear length */
context->Computed = 1; context->Computed = 1;
#ifndef DBUG_OFF
} }
#endif
for (i = 0; i < SHA1_HASH_SIZE; i++) for (i = 0; i < SHA1_HASH_SIZE; i++)
{ Message_Digest[i] = (context->Intermediate_Hash[i>>2] >> 8
Message_Digest[i] = (context->Intermediate_Hash[i>>2] >> 8 * ( 3 - ( i & 0x03 ) ));
* ( 3 - ( i & 0x03 ) ));
}
return SHA_SUCCESS; return SHA_SUCCESS;
} }
/* /*
sha1_input Accepts an array of octets as the next portion of the message.
Description: SYNOPSIS
This function accepts an array of octets as the next portion sha1_input()
of the message. context [in/out] The SHA context to update
message_array An array of characters representing the next portion
Parameters: of the message.
context: [in/out] length The length of the message in message_array
The SHA context to update
message_array: [in] RETURN
An array of characters representing the next portion of SHA_SUCCESS ok
the message. != SHA_SUCCESS sha Error Code.
length: [in]
The length of the message in message_array
Returns:
sha Error Code.
*/ */
int sha1_input(SHA1_CONTEXT *context, const uint8 *message_array, int sha1_input(SHA1_CONTEXT *context, const uint8 *message_array,
unsigned length) unsigned length)
{ {
if (!length) if (!length)
{
return SHA_SUCCESS; return SHA_SUCCESS;
}
#ifndef DBUG_OFF #ifndef DBUG_OFF
/* We assume client konows what it is doing in non-debug mode */ /* We assume client konows what it is doing in non-debug mode */
if (!context || !message_array) if (!context || !message_array)
{
return SHA_NULL; return SHA_NULL;
}
if (context->Computed) if (context->Computed)
{ return (context->Corrupted= SHA_STATE_ERROR);
context->Corrupted = SHA_STATE_ERROR;
return SHA_STATE_ERROR;
}
if (context->Corrupted) if (context->Corrupted)
{
return context->Corrupted; return context->Corrupted;
} #endif
#endif
while (length--) while (length--)
{ {
context->Message_Block[context->Message_Block_Index++] = context->Message_Block[context->Message_Block_Index++]=
(*message_array & 0xFF); (*message_array & 0xFF);
context->Length += 8; /* Length is in bits */ context->Length += 8; /* Length is in bits */
#ifndef DBUG_OFF #ifndef DBUG_OFF
/* /*
Then we're not debugging we assume we never will get message longer Then we're not debugging we assume we never will get message longer
2^64 bits. 2^64 bits.
*/ */
if (context->Length == 0) if (context->Length == 0)
{ return (context->Corrupted= 1); /* Message is too long */
/* Message is too long */ #endif
context->Corrupted = 1;
return 1;
}
#endif
if (context->Message_Block_Index == 64) if (context->Message_Block_Index == 64)
{ {
SHA1ProcessMessageBlock(context); SHA1ProcessMessageBlock(context);
} }
message_array++; message_array++;
} }
return SHA_SUCCESS; return SHA_SUCCESS;
} }
/*
SHA1ProcessMessageBlock
Description:
This function will process the next 512 bits of the message
stored in the Message_Block array.
Parameters:
None.
Returns:
Nothing.
Comments:
Many of the variable names in this code, especially the /*
single character names, were used because those were the Process the next 512 bits of the message stored in the Message_Block array.
names used in the publication.
SYNOPSIS
SHA1ProcessMessageBlock()
DESCRIPTION
Many of the variable names in this code, especially the single
character names, were used because those were the names used in
the publication.
*/ */
/* Constants defined in SHA-1 */ /* Constants defined in SHA-1 */
static const uint32 K[]= static const uint32 K[]=
{ {
0x5A827999, 0x5A827999,
0x6ED9EBA1, 0x6ED9EBA1,
0x8F1BBCDC, 0x8F1BBCDC,
@ -287,17 +239,17 @@ static const uint32 K[]=
}; };
void SHA1ProcessMessageBlock(SHA1_CONTEXT *context) static void SHA1ProcessMessageBlock(SHA1_CONTEXT *context)
{ {
int t; /* Loop counter */ int t; /* Loop counter */
uint32 temp; /* Temporary word value */ uint32 temp; /* Temporary word value */
uint32 W[80]; /* Word sequence */ uint32 W[80]; /* Word sequence */
uint32 A, B, C, D, E; /* Word buffers */ uint32 A, B, C, D, E; /* Word buffers */
int index; int index;
/* /*
Initialize the first 16 words in the array W Initialize the first 16 words in the array W
*/ */
for (t = 0; t < 16; t++) for (t = 0; t < 16; t++)
{ {
@ -322,15 +274,14 @@ void SHA1ProcessMessageBlock(SHA1_CONTEXT *context)
for (t = 0; t < 20; t++) for (t = 0; t < 20; t++)
{ {
temp = SHA1CircularShift(5,A) + temp= SHA1CircularShift(5,A) + ((B & C) | ((~B) & D)) + E + W[t] + K[0];
((B & C) | ((~B) & D)) + E + W[t] + K[0];
E = D; E = D;
D = C; D = C;
C = SHA1CircularShift(30,B); C = SHA1CircularShift(30,B);
B = A; B = A;
A = temp; A = temp;
} }
for (t = 20; t < 40; t++) for (t = 20; t < 40; t++)
{ {
temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1]; temp = SHA1CircularShift(5,A) + (B ^ C ^ D) + E + W[t] + K[1];
@ -343,8 +294,8 @@ void SHA1ProcessMessageBlock(SHA1_CONTEXT *context)
for (t = 40; t < 60; t++) for (t = 40; t < 60; t++)
{ {
temp = SHA1CircularShift(5,A) + temp= (SHA1CircularShift(5,A) + ((B & C) | (B & D) | (C & D)) + E + W[t] +
((B & C) | (B & D) | (C & D)) + E + W[t] + K[2]; K[2]);
E = D; E = D;
D = C; D = C;
C = SHA1CircularShift(30,B); C = SHA1CircularShift(30,B);
@ -367,73 +318,67 @@ void SHA1ProcessMessageBlock(SHA1_CONTEXT *context)
context->Intermediate_Hash[2] += C; context->Intermediate_Hash[2] += C;
context->Intermediate_Hash[3] += D; context->Intermediate_Hash[3] += D;
context->Intermediate_Hash[4] += E; context->Intermediate_Hash[4] += E;
context->Message_Block_Index = 0; context->Message_Block_Index = 0;
} }
/* /*
SHA1PadMessage Pad message
SYNOPSIS
SHA1PadMessage()
context: [in/out] The context to pad
DESCRIPTION
According to the standard, the message must be padded to an even
512 bits. The first padding bit must be a '1'. The last 64 bits
represent the length of the original message. All bits in between
should be 0. This function will pad the message according to
those rules by filling the Message_Block array accordingly. It
will also call the ProcessMessageBlock function provided
appropriately. When it returns, it can be assumed that the message
digest has been computed.
Description:
According to the standard, the message must be padded to an even
512 bits. The first padding bit must be a '1'. The last 64
bits represent the length of the original message. All bits in
between should be 0. This function will pad the message
according to those rules by filling the Message_Block array
accordingly. It will also call the ProcessMessageBlock function
provided appropriately. When it returns, it can be assumed that
the message digest has been computed.
Parameters:
context: [in/out]
The context to pad
ProcessMessageBlock: [in]
The appropriate SHA*ProcessMessageBlock function
Returns:
Nothing.
*/ */
void SHA1PadMessage(SHA1_CONTEXT *context) void SHA1PadMessage(SHA1_CONTEXT *context)
{ {
/* /*
Check to see if the current message block is too small to hold Check to see if the current message block is too small to hold
the initial padding bits and length. If so, we will pad the the initial padding bits and length. If so, we will pad the
block, process it, and then continue padding into a second block, process it, and then continue padding into a second
block. block.
*/ */
int i=context->Message_Block_Index; int i=context->Message_Block_Index;
if (i > 55) if (i > 55)
{ {
context->Message_Block[i++] = 0x80; context->Message_Block[i++] = 0x80;
bzero((char*) &context->Message_Block[i], bzero((char*) &context->Message_Block[i],
sizeof(context->Message_Block[0])*(64-i)); sizeof(context->Message_Block[0])*(64-i));
context->Message_Block_Index=64; context->Message_Block_Index=64;
/* This function sets context->Message_Block_Index to zero */ /* This function sets context->Message_Block_Index to zero */
SHA1ProcessMessageBlock(context); SHA1ProcessMessageBlock(context);
bzero((char*) &context->Message_Block[0], bzero((char*) &context->Message_Block[0],
sizeof(context->Message_Block[0])*56); sizeof(context->Message_Block[0])*56);
context->Message_Block_Index=56; context->Message_Block_Index=56;
}
}
else else
{ {
context->Message_Block[i++] = 0x80; context->Message_Block[i++] = 0x80;
bzero((char*) &context->Message_Block[i], bzero((char*) &context->Message_Block[i],
sizeof(context->Message_Block[0])*(56-i)); sizeof(context->Message_Block[0])*(56-i));
context->Message_Block_Index=56; context->Message_Block_Index=56;
} }
/* /*
Store the message length as the last 8 octets Store the message length as the last 8 octets
*/ */
context->Message_Block[56] = context->Length >> 56; context->Message_Block[56] = context->Length >> 56;
context->Message_Block[57] = context->Length >> 48; context->Message_Block[57] = context->Length >> 48;
context->Message_Block[58] = context->Length >> 40; context->Message_Block[58] = context->Length >> 40;
@ -445,4 +390,3 @@ void SHA1PadMessage(SHA1_CONTEXT *context)
SHA1ProcessMessageBlock(context); SHA1ProcessMessageBlock(context);
} }

3
sql/ha_berkeley.h
View File

@ -88,8 +88,7 @@ class ha_berkeley: public handler
ha_berkeley(TABLE *table): handler(table), alloc_ptr(0),rec_buff(0), file(0), ha_berkeley(TABLE *table): handler(table), alloc_ptr(0),rec_buff(0), file(0),
int_table_flags(HA_REC_NOT_IN_SEQ | int_table_flags(HA_REC_NOT_IN_SEQ |
HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER | HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER |
HA_NULL_KEY | HA_HAVE_KEY_READ_ONLY | HA_NULL_KEY | HA_BLOB_KEY | HA_NOT_EXACT_COUNT |
HA_BLOB_KEY | HA_NOT_EXACT_COUNT |
HA_PRIMARY_KEY_IN_READ_INDEX | HA_DROP_BEFORE_CREATE | HA_PRIMARY_KEY_IN_READ_INDEX | HA_DROP_BEFORE_CREATE |
HA_AUTO_PART_KEY | HA_TABLE_SCAN_ON_INDEX), HA_AUTO_PART_KEY | HA_TABLE_SCAN_ON_INDEX),
changed_rows(0),last_dup_key((uint) -1),version(0),using_ignore(0) changed_rows(0),last_dup_key((uint) -1),version(0),using_ignore(0)

3
sql/ha_innodb.cc
View File

@ -356,13 +356,12 @@ ha_innobase::update_thd(
/************************************************************************* /*************************************************************************
Opens an InnoDB database. */ Opens an InnoDB database. */
char current_lib[3]; // Set if using current lib
bool bool
innobase_init(void) innobase_init(void)
/*===============*/ /*===============*/
/* out: TRUE if error */ /* out: TRUE if error */
{ {
static char current_lib[3]; // Set if using current lib
int err; int err;
bool ret; bool ret;
char *default_path; char *default_path;

3
sql/ha_innodb.h
View File

@ -77,7 +77,6 @@ class ha_innobase: public handler
ha_innobase(TABLE *table): handler(table), ha_innobase(TABLE *table): handler(table),
int_table_flags(HA_REC_NOT_IN_SEQ | int_table_flags(HA_REC_NOT_IN_SEQ |
HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER | HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER |
HA_HAVE_KEY_READ_ONLY |
HA_NULL_KEY | HA_NULL_KEY |
HA_NOT_EXACT_COUNT | HA_NOT_EXACT_COUNT |
HA_NO_WRITE_DELAYED | HA_NO_WRITE_DELAYED |
@ -98,7 +97,7 @@ class ha_innobase: public handler
ulong index_flags(uint idx) const ulong index_flags(uint idx) const
{ {
return (HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER | return (HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER |
HA_NOT_READ_PREFIX_LAST); HA_NOT_READ_PREFIX_LAST | HA_KEY_READ_ONLY);
} }
uint max_record_length() const { return HA_MAX_REC_LENGTH; } uint max_record_length() const { return HA_MAX_REC_LENGTH; }
uint max_keys() const { return MAX_KEY; } uint max_keys() const { return MAX_KEY; }

2
sql/ha_isam.cc
View File

@ -51,8 +51,6 @@ int ha_isam::open(const char *name, int mode, uint test_if_locked)
info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST); info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED)) if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
(void) nisam_extra(file,HA_EXTRA_WAIT_LOCK); (void) nisam_extra(file,HA_EXTRA_WAIT_LOCK);
if (!table->db_record_offset)
int_table_flags|=HA_REC_NOT_IN_SEQ;
return (0); return (0);
} }

18
sql/ha_isam.h
View File

@ -26,21 +26,20 @@
class ha_isam: public handler class ha_isam: public handler
{ {
N_INFO *file; N_INFO *file;
uint int_table_flags;
public: public:
ha_isam(TABLE *table): handler(table), file(0), ha_isam(TABLE *table): handler(table), file(0)
int_table_flags(HA_READ_RND_SAME | {}
HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER |
HA_HAVE_KEY_READ_ONLY |
HA_KEY_READ_WRONG_STR | HA_DUPP_POS |
HA_NOT_DELETE_WITH_CACHE)
{}
~ha_isam() {} ~ha_isam() {}
const char *table_type() const { return "ISAM"; } const char *table_type() const { return "ISAM"; }
const char *index_type(uint key_number) { return "BTREE"; } const char *index_type(uint key_number) { return "BTREE"; }
const char **bas_ext() const; const char **bas_ext() const;
ulong table_flags() const { return int_table_flags; } ulong table_flags() const
{
return (HA_READ_RND_SAME | HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER |
HA_KEY_READ_WRONG_STR | HA_DUPP_POS | HA_NOT_DELETE_WITH_CACHE |
((table->db_record_offset) ? 0 : HA_REC_NOT_IN_SEQ));
}
uint max_record_length() const { return HA_MAX_REC_LENGTH; } uint max_record_length() const { return HA_MAX_REC_LENGTH; }
uint max_keys() const { return N_MAXKEY; } uint max_keys() const { return N_MAXKEY; }
uint max_key_parts() const { return N_MAXKEY_SEG; } uint max_key_parts() const { return N_MAXKEY_SEG; }
@ -80,5 +79,4 @@ class ha_isam: public handler
int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info); int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info);
THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to, THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
enum thr_lock_type lock_type); enum thr_lock_type lock_type);
}; };

3
sql/ha_myisam.cc
View File

@ -885,7 +885,8 @@ void ha_myisam::info(uint flag)
ref_length=info.reflength; ref_length=info.reflength;
table->db_options_in_use = info.options; table->db_options_in_use = info.options;
block_size=myisam_block_size; block_size=myisam_block_size;
table->keys_in_use &= info.key_map; table->keys_in_use&= info.key_map;
table->keys_for_keyread&= info.key_map;
table->db_record_offset=info.record_offset; table->db_record_offset=info.record_offset;
if (table->key_parts) if (table->key_parts)
memcpy((char*) table->key_info[0].rec_per_key, memcpy((char*) table->key_info[0].rec_per_key,

7
sql/ha_myisam.h
View File

@ -45,7 +45,6 @@ class ha_myisam: public handler
public: public:
ha_myisam(TABLE *table): handler(table), file(0), ha_myisam(TABLE *table): handler(table), file(0),
int_table_flags(HA_READ_RND_SAME | HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER | int_table_flags(HA_READ_RND_SAME | HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER |
HA_HAVE_KEY_READ_ONLY |
HA_NULL_KEY | HA_CAN_FULLTEXT | HA_CAN_SQL_HANDLER | HA_NULL_KEY | HA_CAN_FULLTEXT | HA_CAN_SQL_HANDLER |
HA_DUPP_POS | HA_BLOB_KEY | HA_AUTO_PART_KEY), HA_DUPP_POS | HA_BLOB_KEY | HA_AUTO_PART_KEY),
enable_activate_all_index(1) enable_activate_all_index(1)
@ -55,6 +54,12 @@ class ha_myisam: public handler
const char *index_type(uint key_number); const char *index_type(uint key_number);
const char **bas_ext() const; const char **bas_ext() const;
ulong table_flags() const { return int_table_flags; } ulong table_flags() const { return int_table_flags; }
ulong index_flags(uint inx) const
{
ulong flags=(HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER);
return (flags | ((table->key_info[inx].algorithm == HA_KEY_ALG_FULLTEXT) ?
0 : HA_KEY_READ_ONLY));
}
uint max_record_length() const { return HA_MAX_REC_LENGTH; } uint max_record_length() const { return HA_MAX_REC_LENGTH; }
uint max_keys() const { return MI_MAX_KEY; } uint max_keys() const { return MI_MAX_KEY; }
uint max_key_parts() const { return MAX_REF_PARTS; } uint max_key_parts() const { return MAX_REF_PARTS; }

9
sql/ha_myisammrg.h
View File

@ -35,10 +35,15 @@ class ha_myisammrg: public handler
ulong table_flags() const ulong table_flags() const
{ {
return (HA_REC_NOT_IN_SEQ | HA_READ_RND_SAME | return (HA_REC_NOT_IN_SEQ | HA_READ_RND_SAME |
HA_HAVE_KEY_READ_ONLY | HA_KEYPOS_TO_RNDPOS | HA_KEYPOS_TO_RNDPOS | HA_LASTKEY_ORDER |
HA_LASTKEY_ORDER |
HA_NULL_KEY | HA_BLOB_KEY); HA_NULL_KEY | HA_BLOB_KEY);
} }
ulong index_flags(uint inx) const
{
ulong flags=(HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER);
return (flags | ((table->key_info[inx].algorithm == HA_KEY_ALG_FULLTEXT) ?
0 : HA_KEY_READ_ONLY));
}
uint max_record_length() const { return HA_MAX_REC_LENGTH; } uint max_record_length() const { return HA_MAX_REC_LENGTH; }
uint max_keys() const { return MI_MAX_KEY; } uint max_keys() const { return MI_MAX_KEY; }
uint max_key_parts() const { return MAX_REF_PARTS; } uint max_key_parts() const { return MAX_REF_PARTS; }

4
sql/handler.h
View File

@ -48,7 +48,6 @@
#define HA_TABLE_SCAN_ON_INDEX 4 /* No separate data/index file */ #define HA_TABLE_SCAN_ON_INDEX 4 /* No separate data/index file */
#define HA_REC_NOT_IN_SEQ 8 /* ha_info don't return recnumber; #define HA_REC_NOT_IN_SEQ 8 /* ha_info don't return recnumber;
It returns a position to ha_r_rnd */ It returns a position to ha_r_rnd */
#define HA_HAVE_KEY_READ_ONLY 16 /* Can read only keys (no record) */
#define HA_NO_INDEX 32 /* No index needed for next/prev */ #define HA_NO_INDEX 32 /* No index needed for next/prev */
#define HA_KEY_READ_WRONG_STR 64 /* keyread returns converted strings */ #define HA_KEY_READ_WRONG_STR 64 /* keyread returns converted strings */
#define HA_NULL_KEY 128 /* One can have keys with NULL */ #define HA_NULL_KEY 128 /* One can have keys with NULL */
@ -83,6 +82,7 @@
#define HA_READ_ORDER 8 /* Read through record-keys in order */ #define HA_READ_ORDER 8 /* Read through record-keys in order */
#define HA_ONLY_WHOLE_INDEX 16 /* Can't use part key searches */ #define HA_ONLY_WHOLE_INDEX 16 /* Can't use part key searches */
#define HA_NOT_READ_PREFIX_LAST 32 #define HA_NOT_READ_PREFIX_LAST 32
#define HA_KEY_READ_ONLY 64 /* Support HA_EXTRA_KEYREAD */
/* /*
Parameters for open() (in register form->filestat) Parameters for open() (in register form->filestat)
@ -321,7 +321,7 @@ public:
virtual ulong table_flags(void) const =0; virtual ulong table_flags(void) const =0;
virtual ulong index_flags(uint idx) const virtual ulong index_flags(uint idx) const
{ {
return (HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER); return (HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER | HA_KEY_READ_ONLY);
} }
virtual uint max_record_length() const =0; virtual uint max_record_length() const =0;
virtual uint max_keys() const =0; virtual uint max_keys() const =0;

31
sql/item_strfunc.cc
View File

@ -153,15 +153,15 @@ String *Item_func_aes_encrypt::val_str(String *str)
null_value=0; null_value=0;
aes_length=my_aes_get_size(sptr->length()); // calculate result length aes_length=my_aes_get_size(sptr->length()); // calculate result length
if ( !str->alloc(aes_length) ) // Ensure that memory is free if (!str->alloc(aes_length)) // Ensure that memory is free
{ {
// finally encrypt directly to allocated buffer. // finally encrypt directly to allocated buffer.
if (my_aes_encrypt(sptr->ptr(),sptr->length(),str->ptr(),key->ptr(), if (my_aes_encrypt(sptr->ptr(),sptr->length(), (char*) str->ptr(),
key->length()) == aes_length) key->ptr(), key->length()) == aes_length)
{ {
// we have to get expected result length // We got the expected result length
str->length((uint) aes_length); str->length((uint) aes_length);
return str; return str;
} }
} }
} }
@ -169,9 +169,10 @@ String *Item_func_aes_encrypt::val_str(String *str)
return 0; return 0;
} }
void Item_func_aes_encrypt::fix_length_and_dec() void Item_func_aes_encrypt::fix_length_and_dec()
{ {
max_length=my_aes_get_size(args[0]->max_length); max_length=my_aes_get_size(args[0]->max_length);
} }
@ -184,12 +185,12 @@ String *Item_func_aes_decrypt::val_str(String *str)
if (sptr && key) // Need to have both arguments not NULL if (sptr && key) // Need to have both arguments not NULL
{ {
null_value=0; null_value=0;
if ( !str->alloc(sptr->length()) ) // Ensure that memory is free if (!str->alloc(sptr->length())) // Ensure that memory is free
{ {
// finally decencrypt directly to allocated buffer. // finally decrypt directly to allocated buffer.
length=my_aes_decrypt(sptr->ptr(),sptr->length(),str->ptr(), length=my_aes_decrypt(sptr->ptr(), sptr->length(), (char*) str->ptr(),
key->ptr(),key->length()); key->ptr(), key->length());
if (length>=0) // if we got correct data data if (length >= 0) // if we got correct data data
{ {
str->length((uint) length); str->length((uint) length);
return str; return str;
@ -208,9 +209,9 @@ void Item_func_aes_decrypt::fix_length_and_dec()
/* /*
** Concatinate args with the following premissess Concatenate args with the following premises:
** If only one arg which is ok, return value of arg If only one arg (which is ok), return value of arg
** Don't reallocate val_str() if not absolute necessary. Don't reallocate val_str() if not absolute necessary.
*/ */
String *Item_func_concat::val_str(String *str) String *Item_func_concat::val_str(String *str)

24
sql/opt_range.cc
View File

@ -682,27 +682,27 @@ int SQL_SELECT::test_quick_select(key_map keys_to_use, table_map prev_tables,
{ {
ha_rows found_records; ha_rows found_records;
double found_read_time; double found_read_time;
if (*key) if (*key)
{ {
uint keynr= param.real_keynr[idx];
if ((*key)->type == SEL_ARG::MAYBE_KEY || if ((*key)->type == SEL_ARG::MAYBE_KEY ||
(*key)->maybe_flag) (*key)->maybe_flag)
needed_reg|= (key_map) 1 << param.real_keynr[idx]; needed_reg|= (key_map) 1 << keynr;
found_records=check_quick_select(&param,idx, *key); found_records=check_quick_select(&param, idx, *key);
if (found_records != HA_POS_ERROR && found_records > 2 && if (found_records != HA_POS_ERROR && found_records > 2 &&
head->used_keys & ((table_map) 1 << param.real_keynr[idx]) && head->used_keys & ((table_map) 1 << keynr) &&
(head->file->table_flags() & HA_HAVE_KEY_READ_ONLY)) (head->file->index_flags(keynr) & HA_KEY_READ_ONLY))
{ {
/* /*
** We can resolve this by only reading through this key We can resolve this by only reading through this key.
** Assume that we will read trough the whole key range Assume that we will read trough the whole key range
** and that all key blocks are half full (normally things are and that all key blocks are half full (normally things are
** much better) much better).
*/ */
uint keys_per_block= head->file->block_size/2/ uint keys_per_block= (head->file->block_size/2/
(head->key_info[param.real_keynr[idx]].key_length+ (head->key_info[keynr].key_length+
head->file->ref_length) + 1; head->file->ref_length) + 1);
found_read_time=((double) (found_records+keys_per_block-1)/ found_read_time=((double) (found_records+keys_per_block-1)/
(double) keys_per_block); (double) keys_per_block);
} }

16
sql/sql_base.cc
View File

@ -730,7 +730,8 @@ TABLE *reopen_name_locked_table(THD* thd, TABLE_LIST* table_list)
table->const_table=0; table->const_table=0;
table->outer_join=table->null_row=table->maybe_null=0; table->outer_join=table->null_row=table->maybe_null=0;
table->status=STATUS_NO_RECORD; table->status=STATUS_NO_RECORD;
table->keys_in_use_for_query=table->used_keys= table->keys_in_use; table->keys_in_use_for_query= table->keys_in_use;
table->used_keys= table->keys_for_keyread;
DBUG_RETURN(table); DBUG_RETURN(table);
} }
@ -884,7 +885,8 @@ TABLE *open_table(THD *thd,const char *db,const char *table_name,
table->const_table=0; table->const_table=0;
table->outer_join=table->null_row=table->maybe_null=0; table->outer_join=table->null_row=table->maybe_null=0;
table->status=STATUS_NO_RECORD; table->status=STATUS_NO_RECORD;
table->keys_in_use_for_query=table->used_keys= table->keys_in_use; table->keys_in_use_for_query= table->keys_in_use;
table->used_keys= table->keys_for_keyread;
DBUG_ASSERT(table->key_read == 0); DBUG_ASSERT(table->key_read == 0);
DBUG_RETURN(table); DBUG_RETURN(table);
} }
@ -950,7 +952,8 @@ bool reopen_table(TABLE *table,bool locked)
tmp.null_row= table->null_row; tmp.null_row= table->null_row;
tmp.maybe_null= table->maybe_null; tmp.maybe_null= table->maybe_null;
tmp.status= table->status; tmp.status= table->status;
tmp.keys_in_use_for_query=tmp.used_keys=tmp.keys_in_use; tmp.keys_in_use_for_query= tmp.keys_in_use;
tmp.used_keys= tmp.keys_for_keyread;
/* Get state */ /* Get state */
tmp.key_length= table->key_length; tmp.key_length= table->key_length;
@ -1578,7 +1581,7 @@ Field *find_field_in_table(THD *thd,TABLE *table,const char *name,uint length,
{ {
field->query_id=thd->query_id; field->query_id=thd->query_id;
table->used_fields++; table->used_fields++;
table->used_keys&=field->part_of_key; table->used_keys&= field->part_of_key;
} }
else else
thd->dupp_field=field; thd->dupp_field=field;
@ -1783,7 +1786,8 @@ bool setup_tables(TABLE_LIST *tables)
table->const_table=0; table->const_table=0;
table->outer_join=table->null_row=0; table->outer_join=table->null_row=0;
table->status=STATUS_NO_RECORD; table->status=STATUS_NO_RECORD;
table->keys_in_use_for_query=table->used_keys= table->keys_in_use; table->keys_in_use_for_query= table->keys_in_use;
table->used_keys= table->keys_for_keyread;
table->maybe_null=test(table->outer_join=table_list->outer_join); table->maybe_null=test(table->outer_join=table_list->outer_join);
table->tablenr=tablenr; table->tablenr=tablenr;
table->map= (table_map) 1 << tablenr; table->map= (table_map) 1 << tablenr;
@ -1873,7 +1877,7 @@ insert_fields(THD *thd,TABLE_LIST *tables, const char *db_name,
if (field->query_id == thd->query_id) if (field->query_id == thd->query_id)
thd->dupp_field=field; thd->dupp_field=field;
field->query_id=thd->query_id; field->query_id=thd->query_id;
table->used_keys&=field->part_of_key; table->used_keys&= field->part_of_key;
} }
/* All fields are used */ /* All fields are used */
table->used_fields=table->fields; table->used_fields=table->fields;

4
sql/sql_cache.cc
View File

@ -3063,8 +3063,8 @@ my_bool Query_cache::check_integrity(bool not_locked)
DBUG_PRINT("qcache", ("block 0x%lx, type %u...", DBUG_PRINT("qcache", ("block 0x%lx, type %u...",
(ulong) block, (uint) block->type)); (ulong) block, (uint) block->type));
// Check allignment // Check allignment
if ((((ulonglong)block) % (ulonglong)ALIGN_SIZE(1)) != if ((((long)block) % (long) ALIGN_SIZE(1)) !=
(((ulonglong)first_block) % (ulonglong)ALIGN_SIZE(1))) (((long)first_block) % (long)ALIGN_SIZE(1)))
{ {
DBUG_PRINT("error", DBUG_PRINT("error",
("block 0x%lx do not aligned by %d", (ulong) block, ("block 0x%lx do not aligned by %d", (ulong) block,

9
sql/sql_select.cc
View File

@ -233,7 +233,7 @@ mysql_select(THD *thd,TABLE_LIST *tables,List<Item> &fields,COND *conds,
and no GROUP BY. and no GROUP BY.
TODO: Add check of calculation of GROUP functions and fields: TODO: Add check of calculation of GROUP functions and fields:
SELECT COUNT(*)+table.col1 from table1; SELECT COUNT(*)+table.col1 from table1;
*/ */
join.table=0; join.table=0;
join.tables=0; join.tables=0;
{ {
@ -257,14 +257,7 @@ mysql_select(THD *thd,TABLE_LIST *tables,List<Item> &fields,COND *conds,
} }
TABLE_LIST *table; TABLE_LIST *table;
for (table=tables ; table ; table=table->next) for (table=tables ; table ; table=table->next)
{
join.tables++; join.tables++;
if (!thd->used_tables)
{
TABLE *tbl=table->table;
tbl->keys_in_use_for_query=tbl->used_keys= tbl->keys_in_use=0;
}
}
} }
procedure=setup_procedure(thd,proc_param,result,fields,&error); procedure=setup_procedure(thd,proc_param,result,fields,&error);
if (error) if (error)

18
sql/table.cc
View File

@ -133,7 +133,7 @@ int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
if (read_string(file,(gptr*) &disk_buff,key_info_length)) if (read_string(file,(gptr*) &disk_buff,key_info_length))
goto err_not_open; /* purecov: inspected */ goto err_not_open; /* purecov: inspected */
outparam->keys=keys= disk_buff[0]; outparam->keys=keys= disk_buff[0];
outparam->keys_in_use= set_bits(key_map, keys); outparam->keys_for_keyread= outparam->keys_in_use= set_bits(key_map, keys);
outparam->key_parts=key_parts=disk_buff[1]; outparam->key_parts=key_parts=disk_buff[1];
n_length=keys*sizeof(KEY)+key_parts*sizeof(KEY_PART_INFO); n_length=keys*sizeof(KEY)+key_parts*sizeof(KEY_PART_INFO);
@ -199,6 +199,7 @@ int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
for (i=0 ; i < keys ; i++, keyinfo++) for (i=0 ; i < keys ; i++, keyinfo++)
keyinfo->algorithm= (enum ha_key_alg) *(strpos++); keyinfo->algorithm= (enum ha_key_alg) *(strpos++);
} }
outparam->reclength = uint2korr((head+16)); outparam->reclength = uint2korr((head+16));
if (*(head+26) == 1) if (*(head+26) == 1)
outparam->system=1; /* one-record-database */ outparam->system=1; /* one-record-database */
@ -386,7 +387,17 @@ int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
for (uint key=0 ; key < outparam->keys ; key++,keyinfo++) for (uint key=0 ; key < outparam->keys ; key++,keyinfo++)
{ {
uint usable_parts=0; uint usable_parts=0;
ulong index_flags;
keyinfo->name=(char*) outparam->keynames.type_names[key]; keyinfo->name=(char*) outparam->keynames.type_names[key];
/* Fix fulltext keys for old .frm files */
if (outparam->key_info[key].flags & HA_FULLTEXT)
outparam->key_info[key].algorithm= HA_KEY_ALG_FULLTEXT;
/* This has to be done after the above fulltext correction */
index_flags=outparam->file->index_flags(key);
if (!(index_flags & HA_KEY_READ_ONLY))
outparam->keys_for_keyread&= ~((key_map) 1 << key);
if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME)) if (primary_key >= MAX_KEY && (keyinfo->flags & HA_NOSAME))
{ {
/* /*
@ -444,7 +455,7 @@ int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
keyinfo->key_length ? UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG); keyinfo->key_length ? UNIQUE_KEY_FLAG : MULTIPLE_KEY_FLAG);
if (i == 0) if (i == 0)
field->key_start|= ((key_map) 1 << key); field->key_start|= ((key_map) 1 << key);
if ((ha_option & HA_HAVE_KEY_READ_ONLY) && if ((index_flags & HA_KEY_READ_ONLY) &&
field->key_length() == key_part->length && field->key_length() == key_part->length &&
field->type() != FIELD_TYPE_BLOB) field->type() != FIELD_TYPE_BLOB)
{ {
@ -454,8 +465,7 @@ int openfrm(const char *name, const char *alias, uint db_stat, uint prgflag,
field->part_of_key|= ((key_map) 1 << key); field->part_of_key|= ((key_map) 1 << key);
if ((field->key_type() != HA_KEYTYPE_TEXT || if ((field->key_type() != HA_KEYTYPE_TEXT ||
!(keyinfo->flags & HA_FULLTEXT)) && !(keyinfo->flags & HA_FULLTEXT)) &&
!(outparam->file->index_flags(key) & !(index_flags & HA_WRONG_ASCII_ORDER))
HA_WRONG_ASCII_ORDER))
field->part_of_sortkey|= ((key_map) 1 << key); field->part_of_sortkey|= ((key_map) 1 << key);
} }
if (!(key_part->key_part_flag & HA_REVERSE_SORT) && if (!(key_part->key_part_flag & HA_REVERSE_SORT) &&

4
sql/table.h
View File

@ -61,7 +61,8 @@ struct st_table {
uint uniques; uint uniques;
uint null_fields; /* number of null fields */ uint null_fields; /* number of null fields */
uint blob_fields; /* number of blob fields */ uint blob_fields; /* number of blob fields */
key_map keys_in_use, keys_in_use_for_query; key_map keys_in_use, keys_for_keyread;
key_map quick_keys, used_keys, keys_in_use_for_query;
KEY *key_info; /* data of keys in database */ KEY *key_info; /* data of keys in database */
TYPELIB keynames; /* Pointers to keynames */ TYPELIB keynames; /* Pointers to keynames */
ha_rows max_rows; /* create information */ ha_rows max_rows; /* create information */
@ -119,7 +120,6 @@ struct st_table {
byte *record_pointers; /* If sorted in memory */ byte *record_pointers; /* If sorted in memory */
ha_rows found_records; /* How many records in sort */ ha_rows found_records; /* How many records in sort */
ORDER *group; ORDER *group;
key_map quick_keys, used_keys;
ha_rows quick_rows[MAX_KEY]; ha_rows quick_rows[MAX_KEY];
uint quick_key_parts[MAX_KEY]; uint quick_key_parts[MAX_KEY];
key_part_map const_key_parts[MAX_KEY]; key_part_map const_key_parts[MAX_KEY];