开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
userInterface.cpp
资源名称：mysql-4.1.16-win-src.zip　[点击查看]
上传用户：romrleung
上传日期：2022-05-23
资源大小：18897k
文件大小：21k
源码类别：

MySQL数据库

开发平台：

Visual C++

userInterface.cpp：源码内容
  1. /* Copyright (C) 2003 MySQL AB
  3.    This program is free software; you can redistribute it and/or modify
  4.    it under the terms of the GNU General Public License as published by
  5.    the Free Software Foundation; either version 2 of the License, or
  6.    (at your option) any later version.
  8.    This program is distributed in the hope that it will be useful,
  9.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  10.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11.    GNU General Public License for more details.
  13.    You should have received a copy of the GNU General Public License
  14.    along with this program; if not, write to the Free Software
  15.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  17. /***************************************************************
  18. * I N C L U D E D   F I L E S                                  *
  19. ***************************************************************/
  21. #include <ndb_global.h>
  22. #ifndef NDB_WIN32
  23. #include <sys/time.h>
  24. #endif
  26. #include "ndb_error.hpp"
  27. #include "userInterface.h"
  28. #include <NdbThread.h>
  29. #include <NdbTick.h>
  30. #include <NdbMutex.h>
  31. #include <NdbSleep.h>
  32. #include "ndb_schema.hpp"
  33. #include <NDBT.hpp>
  34. #include <NdbSchemaCon.hpp>
  36. /***************************************************************
  37. * L O C A L   C O N S T A N T S                                *
  38. ***************************************************************/
  40. /***************************************************************
  41. * L O C A L   D A T A   S T R U C T U R E S                    *
  42. ***************************************************************/
  44. /***************************************************************
  45. * L O C A L   F U N C T I O N S                                *
  46. ***************************************************************/
  48. extern int localDbPrepare(UserHandle *uh);
  50. static int dbCreate(UserHandle *uh);
  52. /***************************************************************
  53. * L O C A L   D A T A                                          *
  54. ***************************************************************/
  56. /***************************************************************
  57. * P U B L I C   D A T A                                        *
  58. ***************************************************************/
  61. /***************************************************************
  62. ****************************************************************
  63. * 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      *
  64. ****************************************************************
  65. ***************************************************************/
  67. /***************************************************************
  68. ****************************************************************
  69. * 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    *
  70. ****************************************************************
  71. ***************************************************************/
  73. /*-----------------------------------*/
  74. /* Time related Functions            */
  75. /*                                   */
  76. /* Returns a double value in seconds */
  77. /*-----------------------------------*/
  78. double userGetTimeSync(void)
  79. {
  80.   static int initialized = 0;
  81.   static NDB_TICKS initSecs = 0;
  82.   static Uint32 initMicros = 0;
  83.   double timeValue = 0;
  85.   if ( !initialized ) {
  86.     initialized = 1;
  87.     NdbTick_CurrentMicrosecond(&initSecs, &initMicros);  
  88.     timeValue = 0.0;
  89.   } else {
  90.     NDB_TICKS secs = 0;
  91.     Uint32 micros = 0;
  92.   
  93.     NdbTick_CurrentMicrosecond(&secs, &micros);
  95.     double s  = (double)secs  - (double)initSecs;
  96.     double us = (double)secs - (double)initMicros;
  97.     
  98.     timeValue = s + (us / 1000000.0);
  99.   }
  101.   return timeValue;
  102. }
  104. // 0 - OK
  105. // 1 - Retry transaction
  106. // 2 - Permanent
  107. int 
  108. userDbCommit(UserHandle *uh){
  109.   if(uh->pCurrTrans != 0){
  110.     int check = uh->pCurrTrans->execute( Commit ); 
  111.     NdbError err = uh->pCurrTrans->getNdbError();
  112.     uh->pNDB->closeTransaction(uh->pCurrTrans);
  113.     uh->pCurrTrans = 0;
  114.     
  115.     if(err.status != NdbError::Success)
  116.       ndbout << err << endl;
  117.     
  118.     if(err.status == NdbError::TemporaryError && 
  119.        err.classification == NdbError::OverloadError){
  120.       NdbSleep_SecSleep(3);
  121.     }
  122.     
  123.     return err.status;
  124.   }
  125.   return 2;
  126. }
  128. /**
  129.  * TRUE - Normal table
  130.  * FALSE - Table w.o. checkpoing and logging
  131.  */
  133. #ifdef __cplusplus
  134. extern "C" {
  135. #endif
  136. extern int useTableLogging;
  137. #ifdef __cplusplus
  138. }
  139. #endif
  142. int
  143. create_table_server(Ndb * pNdb){
  144.   int check;
  145.   NdbSchemaCon * MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
  146.   if( MySchemaTransaction == NULL )
  147.     error_handler("startSchemaTransaction", pNdb->getNdbError(), 0);
  148.   
  149.   NdbSchemaOp * MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
  150.   if( MySchemaOp == NULL ) 
  151.     error_handler("getNdbSchemaOp", MySchemaTransaction->getNdbError(), 0);
  152.   
  153.   // Create table
  154.   check = MySchemaOp->createTable( SERVER_TABLE,
  155.    8,       // Table size
  156.    TupleKey, // Key Type
  157.    1 // Nr of Pages
  158.    ,DistributionGroup,
  159.    6,
  160.    78,
  161.    80,
  162.    1,
  163.    useTableLogging
  164.                                    );
  165.   if( check == -1 ) 
  166.     error_handler("createTable", MySchemaTransaction->getNdbError(), 0);
  167.   
  168.   check = MySchemaOp->createAttribute
  169.     ( SERVER_SUBSCRIBER_SUFFIX,
  170.       TupleKey, 
  171.       sizeof(char) << 3,
  172.       SUBSCRIBER_NUMBER_SUFFIX_LENGTH,
  173.       String, 
  174.       MMBased,
  175.       NotNullAttribute,
  176.       NormalStorageAttribute,
  177.       0,
  178.       1,
  179.       16);
  180.   if( check == -1 ) 
  181.     error_handler("createAttribute (subscriber suffix)", 
  182.   MySchemaTransaction->getNdbError(), 0);
  184.   // Create first column, primary key 
  185.   check = MySchemaOp->createAttribute( SERVER_ID,
  186.        TupleKey, 
  187.        sizeof(ServerId) << 3,
  188.        1,
  189.        UnSigned, 
  190.        MMBased,
  191.        NotNullAttribute );
  192.   if( check == -1 ) 
  193.     error_handler("createAttribute (serverid)", 
  194.   MySchemaTransaction->getNdbError(), 0);
  197.   check = MySchemaOp->createAttribute( SERVER_NAME,
  198.        NoKey, 
  199.        sizeof(char) << 3,
  200.        SERVER_NAME_LENGTH,
  201.        String, 
  202.        MMBased,
  203.        NotNullAttribute );
  204.   if( check == -1 ) 
  205.     error_handler("createAttribute (server name)", 
  206.   MySchemaTransaction->getNdbError(), 0);
  207.   
  209.   check = MySchemaOp->createAttribute( SERVER_READS,
  210.        NoKey, 
  211.        sizeof(Counter) << 3,
  212.        1,
  213.        UnSigned,
  214.        MMBased,
  215.        NotNullAttribute );
  216.   if( check == -1 ) 
  217.     error_handler("createAttribute (server reads)", 
  218.   MySchemaTransaction->getNdbError(), 0);
  220.   check = MySchemaOp->createAttribute( SERVER_INSERTS,
  221.        NoKey, 
  222.        sizeof(Counter) << 3,
  223.        1,
  224.        UnSigned,
  225.        MMBased,
  226.        NotNullAttribute );
  227.   if( check == -1 ) 
  228.     error_handler("createAttribute (server inserts)", 
  229.   MySchemaTransaction->getNdbError(), 0);
  231.   check = MySchemaOp->createAttribute( SERVER_DELETES,
  232.        NoKey, 
  233.        sizeof(Counter) << 3,
  234.        1,
  235.        UnSigned,
  236.        MMBased,
  237.        NotNullAttribute );
  238.   if( check == -1 ) 
  239.     error_handler("createAttribute (server deletes)", 
  240.   MySchemaTransaction->getNdbError(), 0);
  241.   
  242.   if( MySchemaTransaction->execute() == -1 ) {
  243.     error_handler("schemaTransaction->execute()", 
  244.   MySchemaTransaction->getNdbError(), 0);
  245.   }    
  246.   NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  247.   return 0;
  248. }
  250. int
  251. create_table_group(Ndb * pNdb){
  252.   int check;
  254.   NdbSchemaCon * MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
  255.   if( MySchemaTransaction == NULL )
  256.     error_handler("startSchemaTransaction", pNdb->getNdbError(), 0);
  257.   
  258.   NdbSchemaOp * MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
  259.   if( MySchemaOp == NULL ) 
  260.     error_handler("getNdbSchemaOp", MySchemaTransaction->getNdbError(), 0);
  261.   
  262.   // Create table
  263.   check = MySchemaOp->createTable( GROUP_TABLE,
  264.    8,       // Table size
  265.    TupleKey, // Key Type
  266.    1 // Nr of Pages
  267.    ,All,
  268.    6,
  269.    78,
  270.    80,
  271.    1,
  272.    useTableLogging
  273.                                    );
  275.   if( check == -1 ) 
  276.     error_handler("createTable", MySchemaTransaction->getNdbError(), 0);
  277.   
  278.   // Create first column, primary key 
  279.   check = MySchemaOp->createAttribute( GROUP_ID,
  280.        TupleKey, 
  281.        sizeof(GroupId) << 3,
  282.        1,
  283.        UnSigned, 
  284.        MMBased,
  285.        NotNullAttribute );
  286.   if( check == -1 ) 
  287.     error_handler("createAttribute (group id)", 
  288.   MySchemaTransaction->getNdbError(), 0);
  290.   check = MySchemaOp->createAttribute( GROUP_NAME,
  291.        NoKey,
  292.        sizeof(char) << 3,
  293.        GROUP_NAME_LENGTH,
  294.        String, 
  295.        MMBased,
  296.        NotNullAttribute );
  297.   if( check == -1 ) 
  298.     error_handler("createAttribute (group name)", 
  299.   MySchemaTransaction->getNdbError(), 0);
  300.   
  302.   check = MySchemaOp->createAttribute( GROUP_ALLOW_READ,
  303.        NoKey, 
  304.        sizeof(Permission) << 3,
  305.        1,
  306.        String, 
  307.        MMBased,
  308.        NotNullAttribute );
  309.   if( check == -1 ) 
  310.     error_handler("createAttribute (group read)", 
  311.   MySchemaTransaction->getNdbError(), 0);
  312.   
  314.   check = MySchemaOp->createAttribute( GROUP_ALLOW_INSERT,
  315.        NoKey, 
  316.        sizeof(Permission) << 3,
  317.        1,
  318.        UnSigned,
  319.        MMBased,
  320.        NotNullAttribute );
  321.   if( check == -1 ) 
  322.     error_handler("createAttribute (group insert)", 
  323.   MySchemaTransaction->getNdbError(), 0);
  325.   check = MySchemaOp->createAttribute( GROUP_ALLOW_DELETE,
  326.        NoKey, 
  327.        sizeof(Permission) << 3,
  328.        1,
  329.        UnSigned,
  330.        MMBased,
  331.        NotNullAttribute );
  332.   if( check == -1 ) 
  333.     error_handler("createAttribute (group delete)", 
  334.   MySchemaTransaction->getNdbError(), 0);
  335.   
  336.   if( MySchemaTransaction->execute() == -1 ) {
  337.     error_handler("schemaTransaction->execute()", 
  338.   MySchemaTransaction->getNdbError(), 0);
  339.   }    
  340.   NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  341.   return 0;
  342. }
  344. int
  345. create_table_subscriber(Ndb * pNdb){
  346.   int check;
  347.   NdbSchemaCon * MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
  348.   if( MySchemaTransaction == NULL )
  349.     error_handler("startSchemaTransaction", pNdb->getNdbError(), 0);
  350.   
  351.   NdbSchemaOp * MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
  352.   if( MySchemaOp == NULL ) 
  353.     error_handler("getNdbSchemaOp", MySchemaTransaction->getNdbError(), 0);
  354.   
  355.   // Create table
  356.   check = MySchemaOp->createTable( SUBSCRIBER_TABLE,
  357.    8,       // Table size
  358.    TupleKey, // Key Type
  359.    1 // Nr of Pages
  360.    ,DistributionGroup,
  361.    6,
  362.    78,
  363.    80,
  364.    1,
  365.    useTableLogging
  366.                                    );
  367.   if( check == -1 ) 
  368.     error_handler("createTable", MySchemaTransaction->getNdbError(), 0);
  369.   
  370.   // Create first column, primary key 
  371.   check = MySchemaOp->createAttribute
  372.     ( SUBSCRIBER_NUMBER,
  373.       TupleKey, 
  374.       sizeof(char) << 3,
  375.       SUBSCRIBER_NUMBER_LENGTH,
  376.       String, 
  377.       MMBased,
  378.       NotNullAttribute,
  379.       NormalStorageAttribute,
  380.       0,
  381.       1,
  382.       16);
  383.   if( check == -1 ) 
  384.     error_handler("createAttribute (subscriber number)", 
  385.   MySchemaTransaction->getNdbError(), 0);
  386.   
  387.   check = MySchemaOp->createAttribute( SUBSCRIBER_NAME,
  388.        NoKey, 
  389.        sizeof(char) << 3,
  390.        SUBSCRIBER_NAME_LENGTH,
  391.        String, 
  392.        MMBased,
  393.        NotNullAttribute );
  394.   if( check == -1 ) 
  395.     error_handler("createAttribute (subscriber name)", 
  396.   MySchemaTransaction->getNdbError(), 0);
  397.   
  399.   check = MySchemaOp->createAttribute( SUBSCRIBER_GROUP,
  400.        NoKey, 
  401.        sizeof(GroupId) << 3,
  402.        1,
  403.        UnSigned,
  404.        MMBased,
  405.        NotNullAttribute );
  406.   if( check == -1 ) 
  407.     error_handler("createAttribute (subscriber_group)", 
  408.   MySchemaTransaction->getNdbError(), 0);
  409.   
  411.   check = MySchemaOp->createAttribute( SUBSCRIBER_LOCATION,
  412.        NoKey, 
  413.        sizeof(Location) << 3,
  414.        1,
  415.        UnSigned,
  416.        MMBased,
  417.        NotNullAttribute );
  418.   if( check == -1 ) 
  419.     error_handler("createAttribute (server reads)", 
  420.   MySchemaTransaction->getNdbError(), 0);
  422.   check = MySchemaOp->createAttribute( SUBSCRIBER_SESSIONS,
  423.        NoKey, 
  424.        sizeof(ActiveSessions) << 3,
  425.        1,
  426.        UnSigned,
  427.        MMBased,
  428.        NotNullAttribute );
  429.   if( check == -1 ) 
  430.     error_handler("createAttribute (subscriber_sessions)", 
  431.   MySchemaTransaction->getNdbError(), 0);
  433.   check = MySchemaOp->createAttribute( SUBSCRIBER_CHANGED_BY,
  434.        NoKey, 
  435.        sizeof(char) << 3,
  436.        CHANGED_BY_LENGTH,
  437.        String,
  438.        MMBased,
  439.        NotNullAttribute );
  440.   if( check == -1 ) 
  441.     error_handler("createAttribute (subscriber_changed_by)", 
  442.   MySchemaTransaction->getNdbError(), 0);
  444.   check = MySchemaOp->createAttribute( SUBSCRIBER_CHANGED_TIME,
  445.        NoKey, 
  446.        sizeof(char) << 3,
  447.        CHANGED_TIME_LENGTH,
  448.        String,
  449.        MMBased,
  450.        NotNullAttribute );
  451.   if( check == -1 ) 
  452.     error_handler("createAttribute (subscriber_changed_time)", 
  453.   MySchemaTransaction->getNdbError(), 0);
  454.   
  455.   if( MySchemaTransaction->execute() == -1 ) {
  456.     error_handler("schemaTransaction->execute()", 
  457.   MySchemaTransaction->getNdbError(), 0);
  458.   }    
  459.   NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  460.   return 0;
  461. }
  463. int
  464. create_table_session(Ndb * pNdb){
  465.   int check;
  466.   NdbSchemaCon * MySchemaTransaction = NdbSchemaCon::startSchemaTrans(pNdb);
  467.   if( MySchemaTransaction == NULL )
  468.     error_handler("startSchemaTransaction", pNdb->getNdbError(), 0);
  469.   
  470.   NdbSchemaOp * MySchemaOp = MySchemaTransaction->getNdbSchemaOp();
  471.   if( MySchemaOp == NULL ) 
  472.     error_handler("getNdbSchemaOp", 
  473.   MySchemaTransaction->getNdbError(), 0);
  474.   
  475.   // Create table
  476.   check = MySchemaOp->createTable( SESSION_TABLE,
  477.    8,       // Table size
  478.    TupleKey, // Key Type
  479.    1 // Nr of Pages
  480.    ,DistributionGroup,
  481.    6,
  482.    78,
  483.    80,
  484.    1,
  485.    useTableLogging
  486.                                    );
  487.   if( check == -1 ) 
  488.     error_handler("createTable", MySchemaTransaction->getNdbError(), 0);
  489.   
  490.   check = MySchemaOp->createAttribute( SESSION_SUBSCRIBER,
  491.        TupleKey, 
  492.        sizeof(char) << 3,
  493.        SUBSCRIBER_NUMBER_LENGTH,
  494.        String, 
  495.        MMBased,
  496.        NotNullAttribute,
  497.        NormalStorageAttribute,
  498.        0,
  499.        1,
  500.        16);
  501.   if( check == -1 ) 
  502.     error_handler("createAttribute (session_subscriber)", 
  503.   MySchemaTransaction->getNdbError(), 0);
  505.   // Create first column, primary key 
  506.   check = MySchemaOp->createAttribute( SESSION_SERVER,
  507.        TupleKey, 
  508.        sizeof(ServerId) << 3,
  509.        1,
  510.        UnSigned,
  511.        MMBased,
  512.        NotNullAttribute );
  513.   if( check == -1 ) 
  514.     error_handler("createAttribute (session_server)", 
  515.   MySchemaTransaction->getNdbError(), 0);
  518.   check = MySchemaOp->createAttribute( SESSION_DATA,
  519.        NoKey, 
  520.        sizeof(char) << 3,
  521.        SESSION_DETAILS_LENGTH,
  522.        String, 
  523.        MMBased,
  524.        NotNullAttribute );
  525.   if( check == -1 ) 
  526.     error_handler("createAttribute (session_data)", 
  527.   MySchemaTransaction->getNdbError(), 0);
  528.   
  529.   if( MySchemaTransaction->execute() == -1 ) {
  530.     error_handler("schemaTransaction->execute()", 
  531.   MySchemaTransaction->getNdbError(), 0);
  532.   }    
  533.   NdbSchemaCon::closeSchemaTrans(MySchemaTransaction);
  534.   return 0;
  535. }
  537. void 
  538. create_table(const char * name, int (* function)(Ndb * pNdb), Ndb* pNdb){
  539.   printf("creating table %s...", name);
  540.   if(pNdb->getDictionary()->getTable(name) != 0){
  541.     printf(" it already existsn");
  542.     return;
  543.   } else {
  544.     printf("n");
  545.   }
  546.   function(pNdb);
  547.   printf("creating table %s... donen", name);
  548. }
  550. static int dbCreate(Ndb * pNdb)
  551. {
  552.   create_table(SUBSCRIBER_TABLE, create_table_subscriber, pNdb);
  553.   create_table(GROUP_TABLE     , create_table_group, pNdb);
  554.   create_table(SESSION_TABLE   , create_table_session, pNdb);
  555.   create_table(SERVER_TABLE    , create_table_server, pNdb);
  556.   return 0;
  557. }
  559. #ifndef NDB_WIN32
  560. #include <unistd.h>
  561. #endif
  563. UserHandle*
  564. userDbConnect(uint32 createDb, char *dbName)
  565. {
  566.   Ndb_cluster_connection *con= new Ndb_cluster_connection();
  567.   if(con->connect(12, 5, 1) != 0)
  568.   {
  569.     ndbout << "Unable to connect to management server." << endl;
  570.     return 0;
  571.   }
  572.   if (con->wait_until_ready(30,0) < 0)
  573.   {
  574.     ndbout << "Cluster nodes not ready in 30 seconds." << endl;
  575.     return 0;
  576.   }
  578.   Ndb * pNdb = new Ndb(con, dbName);
  579.   
  580.   //printf("Initializing...n");
  581.   pNdb->init();
  582.   
  583.   //printf("Waiting...");
  584.   while(pNdb->waitUntilReady() != 0){
  585.     //printf("...");
  586.   }
  587.   //  printf("donen");
  588.   
  589.   if( createDb )
  590.     dbCreate(pNdb);
  591.   
  593.   UserHandle * uh = new UserHandle;
  594.   uh->pNCC       = con;
  595.   uh->pNDB       = pNdb;
  596.   uh->pCurrTrans = 0;
  598.   return uh;
  599. }
  601. void userDbDisconnect(UserHandle *uh)
  602. {
  603.   delete uh;
  604. }
  606. int userDbInsertServer(UserHandle       *uh,
  607.                        ServerId         serverId,
  608.                SubscriberSuffix suffix,
  609.                ServerName       name)
  610. {
  611.   int check;
  613.   uint32 noOfRead   = 0;
  614.   uint32 noOfInsert = 0;
  615.   uint32 noOfDelete = 0;
  617.   NdbConnection * MyTransaction = 0;
  618.   if(uh->pCurrTrans != 0){
  619.     MyTransaction = uh->pCurrTrans;
  620.   } else {
  621.     uh->pCurrTrans = MyTransaction = uh->pNDB->startTransaction();
  622.   }
  623.   if (MyTransaction == NULL)   
  624.     error_handler("startTranscation", uh->pNDB->getNdbError(), 0);
  625.   
  626.   NdbOperation *MyOperation = MyTransaction->getNdbOperation(SERVER_TABLE);
  627.   CHECK_NULL(MyOperation, "getNdbOperation", MyTransaction);
  628.   
  629.   check = MyOperation->insertTuple();
  630.   CHECK_MINUS_ONE(check, "insert tuple", MyTransaction);  
  631.   
  632.   check = MyOperation->equal(SERVER_ID, (char*)&serverId);
  633.   CHECK_MINUS_ONE(check, "setValue id", MyTransaction);  
  634.   
  635.   check = MyOperation->setValue(SERVER_SUBSCRIBER_SUFFIX, suffix);
  636.   CHECK_MINUS_ONE(check, "setValue suffix", MyTransaction);  
  638.   check = MyOperation->setValue(SERVER_NAME, name);
  639.   CHECK_MINUS_ONE(check, "setValue name", MyTransaction);  
  641.   check = MyOperation->setValue(SERVER_READS, (char*)&noOfRead);
  642.   CHECK_MINUS_ONE(check, "setValue reads", MyTransaction);  
  644.   check = MyOperation->setValue(SERVER_INSERTS, (char*)&noOfInsert);
  645.   CHECK_MINUS_ONE(check, "setValue inserts", MyTransaction);  
  647.   check = MyOperation->setValue(SERVER_DELETES, (char*)&noOfDelete);
  648.   CHECK_MINUS_ONE(check, "setValue deletes", MyTransaction);  
  650.   return 0;
  651. }
  653. int userDbInsertSubscriber(UserHandle      *uh,
  654.                    SubscriberNumber number,
  655.                            uint32           groupId,
  656.                    SubscriberName   name)
  657. {
  658.   int check;
  659.   uint32 activeSessions = 0;
  660.   Location l = 0;
  661.   ChangedBy changedBy; snprintf(changedBy, sizeof(changedBy), "ChangedBy");
  662.   ChangedTime changedTime; snprintf(changedTime, sizeof(changedTime), "ChangedTime"); 
  664.   NdbConnection * MyTransaction = 0;
  665.   if(uh->pCurrTrans != 0){
  666.     MyTransaction = uh->pCurrTrans;
  667.   } else {
  668.     uh->pCurrTrans = MyTransaction = uh->pNDB->startTransaction();
  669.   }
  670.   if (MyTransaction == NULL)   
  671.     error_handler("startTranscation", uh->pNDB->getNdbError(), 0);
  672.   
  673.   NdbOperation *MyOperation = MyTransaction->getNdbOperation(SUBSCRIBER_TABLE);
  674.   CHECK_NULL(MyOperation, "getNdbOperation", MyTransaction);
  675.   
  676.   check = MyOperation->insertTuple();
  677.   CHECK_MINUS_ONE(check, "insertTuple", MyTransaction);
  678.   
  679.   check = MyOperation->equal(SUBSCRIBER_NUMBER, number);
  680.   CHECK_MINUS_ONE(check, "equal", MyTransaction);
  682.   check = MyOperation->setValue(SUBSCRIBER_NAME, name);
  683.   CHECK_MINUS_ONE(check, "setValue name", MyTransaction);
  685.   check = MyOperation->setValue(SUBSCRIBER_GROUP, (char*)&groupId);
  686.   CHECK_MINUS_ONE(check, "setValue group", MyTransaction);
  688.   check = MyOperation->setValue(SUBSCRIBER_LOCATION, (char*)&l);
  689.   CHECK_MINUS_ONE(check, "setValue location", MyTransaction);
  691.   check = MyOperation->setValue(SUBSCRIBER_SESSIONS, (char*)&activeSessions);
  692.   CHECK_MINUS_ONE(check, "setValue sessions", MyTransaction);
  694.   check = MyOperation->setValue(SUBSCRIBER_CHANGED_BY, changedBy);
  695.   CHECK_MINUS_ONE(check, "setValue changedBy", MyTransaction);
  697.   check = MyOperation->setValue(SUBSCRIBER_CHANGED_TIME, changedTime);
  698.   CHECK_MINUS_ONE(check, "setValue changedTime", MyTransaction);
  700.   return 0;
  701. }
  703. int userDbInsertGroup(UserHandle *uh,
  704.       GroupId    groupId, 
  705.       GroupName  name,
  706.       Permission allowRead,
  707.       Permission allowInsert,
  708.       Permission allowDelete)
  709. {
  710.   int check;
  711.   
  712.   NdbConnection * MyTransaction = 0;
  713.   if(uh->pCurrTrans != 0){
  714.     MyTransaction = uh->pCurrTrans;
  715.   } else {
  716.     uh->pCurrTrans = MyTransaction = uh->pNDB->startTransaction();
  717.   }
  718.   if (MyTransaction == NULL)   
  719.     error_handler("startTranscation", uh->pNDB->getNdbError(), 0);
  721.   NdbOperation *MyOperation = MyTransaction->getNdbOperation(GROUP_TABLE);
  722.   CHECK_NULL(MyOperation, "getNdbOperation", MyTransaction);  
  723.   
  724.   check = MyOperation->insertTuple();
  725.   CHECK_MINUS_ONE(check, "insertTuple", MyTransaction);  
  726.   
  727.   check = MyOperation->equal(GROUP_ID, (char*)&groupId);
  728.   CHECK_MINUS_ONE(check, "equal", MyTransaction);  
  729.   
  730.   check = MyOperation->setValue(GROUP_NAME, name);
  731.   CHECK_MINUS_ONE(check, "setValue name", MyTransaction);  
  733.   check = MyOperation->setValue(GROUP_ALLOW_READ, (char*)&allowRead);
  734.   CHECK_MINUS_ONE(check, "setValue allowRead", MyTransaction);  
  736.   check = MyOperation->setValue(GROUP_ALLOW_INSERT, (char*)&allowInsert);
  737.   CHECK_MINUS_ONE(check, "setValue allowInsert", MyTransaction);  
  739.   check = MyOperation->setValue(GROUP_ALLOW_DELETE, (char*)&allowDelete);
  740.   CHECK_MINUS_ONE(check, "setValue allowDelete", MyTransaction);  
  741.   
  742.   return 0;
  743. }