dbPopulate.c
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:7k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2003 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /***************************************************************
  14. * I N C L U D E D   F I L E S                                  *
  15. ***************************************************************/
  16. #include <ndb_global.h>
  17. #include "userInterface.h"
  18. #include "dbPopulate.h"
  19. #include <NdbOut.hpp>
  20. #include <random.h>
  21. /***************************************************************
  22. * L O C A L   C O N S T A N T S                                *
  23. ***************************************************************/
  24. /***************************************************************
  25. * L O C A L   D A T A   S T R U C T U R E S                    *
  26. ***************************************************************/
  27. /***************************************************************
  28. * L O C A L   F U N C T I O N S                                *
  29. ***************************************************************/
  30. static void getRandomSubscriberData(int              subscriberNo, 
  31.                     SubscriberNumber number,
  32.                     SubscriberName   name);
  33. static void populate(char *title,
  34.                      int   count,
  35.                      void (*func)(UserHandle*,int),
  36.                      UserHandle *uh);
  37. static void populateServers(UserHandle *uh, int count);
  38. static void populateSubscribers(UserHandle *uh, int count);
  39. static void populateGroups(UserHandle *uh, int count);
  40. /***************************************************************
  41. * L O C A L   D A T A                                          *
  42. ***************************************************************/
  43. static SequenceValues permissionsDefinition[] = {
  44.    {90, 1},
  45.    {10, 0},
  46.    {0,  0}
  47. };
  48. /***************************************************************
  49. * P U B L I C   D A T A                                        *
  50. ***************************************************************/
  51. /***************************************************************
  52. ****************************************************************
  53. * L O C A L   F U N C T I O N S   C O D E   S E C T I O N      *
  54. ****************************************************************
  55. ***************************************************************/
  56. static void getRandomSubscriberData(int              subscriberNo, 
  57.                     SubscriberNumber number,
  58.                     SubscriberName   name)
  59. {
  60.    char sbuf[SUBSCRIBER_NUMBER_LENGTH + 1];
  61.    sprintf(sbuf, "%.*d", SUBSCRIBER_NUMBER_LENGTH, subscriberNo);
  62.    memcpy(number, sbuf, SUBSCRIBER_NUMBER_LENGTH);
  63.    memset(name, myRandom48(26)+'A', SUBSCRIBER_NAME_LENGTH);
  64. }
  65. static void populate(char *title,
  66.                      int   count,
  67.                      void (*func)(UserHandle*, int),
  68.                      UserHandle *uh)
  69. {
  70.    ndbout_c("Populating %d '%s' ... ",count, title);
  71.    /* fflush(stdout); */
  72.    func(uh,count);
  73.    ndbout_c("done");
  74. }
  75. static void populateServers(UserHandle *uh, int count)
  76. {
  77.    int  i, j;
  78.    int len;
  79.    char tmp[80];
  80.    int suffix_length = 1;
  81.    ServerName serverName;
  82.    SubscriberSuffix suffix;
  83.    int commitCount = 0;
  84.    for(i = 0; i < SUBSCRIBER_NUMBER_SUFFIX_LENGTH; i++)
  85.      suffix_length *= 10;
  86.    for(i = 0; i < count; i++) {
  87.       sprintf(tmp, "-Server %d-", i);
  88.       len = strlen(tmp);
  89.       for(j = 0; j < SERVER_NAME_LENGTH; j++){
  90.          serverName[j] = tmp[j % len];
  91.       }
  92.       /* serverName[j] = 0; not null-terminated */
  93.       for(j = 0; j < suffix_length; j++){
  94.  char sbuf[SUBSCRIBER_NUMBER_SUFFIX_LENGTH + 1];
  95.          sprintf(sbuf, "%.*d", SUBSCRIBER_NUMBER_SUFFIX_LENGTH, j);
  96.  memcpy(suffix, sbuf, SUBSCRIBER_NUMBER_SUFFIX_LENGTH);
  97.          userDbInsertServer(uh, i, suffix, serverName);
  98.  commitCount ++;
  99.  if((commitCount % OP_PER_TRANS) == 0)
  100.    userDbCommit(uh);
  101.       }
  102.    }
  103.    if((commitCount % OP_PER_TRANS) != 0)
  104.      userDbCommit(uh);
  105. }
  106. static void populateSubscribers(UserHandle *uh, int count)
  107. {
  108.    SubscriberNumber number;
  109.    SubscriberName   name;
  110.    int i, j, k;
  111.    int res;
  112.    SequenceValues values[NO_OF_GROUPS+1];
  113.    RandomSequence seq;
  114.    for(i = 0; i < NO_OF_GROUPS; i++) {
  115.       values[i].length = 1;
  116.       values[i].value  = i;
  117.    }
  118.    values[i].length = 0;
  119.    values[i].value  = 0;
  120.    if( initSequence(&seq, values) != 0 ) {
  121.       ndbout_c("could not set the sequence of random groups");
  122.       exit(0);
  123.    }
  124. #define RETRIES 25
  125.    for(i = 0; i < count; i+= OP_PER_TRANS) {
  126.      for(j = 0; j<RETRIES; j++){
  127.        for(k = 0; k<OP_PER_TRANS && i+k < count; k++){
  128.  getRandomSubscriberData(i+k, number, name);
  129.  userDbInsertSubscriber(uh, number, getNextRandom(&seq), name);
  130.        }
  131.        res = userDbCommit(uh);
  132.        if(res == 0)
  133.  break;
  134.        if(res != 1){
  135.  ndbout_c("Terminating");
  136.  exit(0);
  137.        }
  138.      }
  139.      if(j == RETRIES){
  140.        ndbout_c("Terminating");
  141.        exit(0);
  142.      }
  143.    }
  144. }
  145. static void populateGroups(UserHandle *uh, int count)
  146. {
  147.    int i;
  148.    int j;
  149.    int len;
  150.    RandomSequence seq;
  151.    Permission     allow[NO_OF_GROUPS];
  152.    ServerBit      serverBit;
  153.    GroupName      groupName;
  154.    char           tmp[80];
  155.    int commitCount = 0;
  156.    if( initSequence(&seq, permissionsDefinition) != 0 ) {
  157.       ndbout_c("could not set the sequence of random permissions");
  158.       exit(0);
  159.    }
  160.    for(i = 0; i < NO_OF_GROUPS; i++)
  161.       allow[i] = 0;
  162.    for(i = 0; i < NO_OF_SERVERS; i++) {
  163.       serverBit = 1 << i;
  164.       for(j = 0; j < NO_OF_GROUPS; j++ ) {
  165.          if( getNextRandom(&seq) )
  166.             allow[j] |= serverBit;
  167.       }
  168.    }
  169.    for(i = 0; i < NO_OF_GROUPS; i++) {
  170.       sprintf(tmp, "-Group %d-", i);
  171.       len = strlen(tmp);
  172.       for(j = 0; j < GROUP_NAME_LENGTH; j++) {
  173.         groupName[j] = tmp[j % len];
  174.       }
  175.       /* groupName[j] = 0; not null-terminated */
  176.       userDbInsertGroup(uh,
  177.         i,
  178.         groupName,
  179.         allow[i],
  180.         allow[i],
  181.         allow[i]);
  182.       commitCount ++;
  183.       if((commitCount % OP_PER_TRANS) == 0)
  184. userDbCommit(uh);
  185.    }
  186.    if((commitCount % OP_PER_TRANS) != 0)
  187.      userDbCommit(uh);
  188. }
  189. /***************************************************************
  190. ****************************************************************
  191. * P U B L I C   F U N C T I O N S   C O D E   S E C T I O N    *
  192. ****************************************************************
  193. ***************************************************************/
  194. void dbPopulate(UserHandle *uh)
  195. {
  196.    populate("servers", NO_OF_SERVERS, populateServers, uh);
  197.    populate("subscribers", NO_OF_SUBSCRIBERS, populateSubscribers, uh);
  198.    populate("groups", NO_OF_GROUPS, populateGroups, uh);
  199. }