const char * ndbGetVersionString(Uint32 version, Uint32 mysql_version,
const char * status,
char *buf, unsigned sz)
{
char tmp[NDB_VERSION_STRING_BUF_SZ];
if (status && status[0] != 0)
basestring_snprintf(tmp, sizeof(tmp), "%s", status);
else
tmp[0] = 0;
if (mysql_version)
{
basestring_snprintf(buf, sz, "mysql-%d.%d.%d ndb-%d.%d.%d%s",
getMajor(mysql_version),
getMinor(mysql_version),
getBuild(mysql_version),
getMajor(version),
getMinor(version),
getBuild(version),
tmp);
}
else
{
basestring_snprintf(buf, sz, "ndb-%d.%d.%d%s",
getMajor(version),
getMinor(version),
getBuild(version),
tmp);
}
return buf;
}
static
void
ndbPrintCompatibleTable(struct NdbUpGradeCompatible table[])
{
int i;
printf("ownVersion, matchType, otherVersion\n");
for (i = 0; table[i].ownVersion != 0 && table[i].otherVersion != 0; i++) {
printf("%u.%u.%u, ",
getMajor(table[i].ownVersion),
getMinor(table[i].ownVersion),
getBuild(table[i].ownVersion));
switch (table[i].matchType) {
case UG_Range:
printf("Range");
break;
case UG_Exact:
printf("Exact");
break;
default:
break;
}
printf(", %u.%u.%u\n",
getMajor(table[i].otherVersion),
getMinor(table[i].otherVersion),
getBuild(table[i].otherVersion));
}
printf("\n");
}
void
ClusterMgr::execAPI_REGREQ(const Uint32 * theData){
const ApiRegReq * const apiRegReq = (ApiRegReq *)&theData[0];
const NodeId nodeId = refToNode(apiRegReq->ref);
#ifdef DEBUG_REG
ndbout_c("ClusterMgr: Recd API_REGREQ from node %d", nodeId);
#endif
assert(nodeId > 0 && nodeId < MAX_NODES);
Node & cm_node = theNodes[nodeId];
trp_node & node = cm_node;
assert(node.defined == true);
assert(node.is_connected() == true);
if(node.m_info.m_version != apiRegReq->version){
node.m_info.m_version = apiRegReq->version;
node.m_info.m_mysql_version = apiRegReq->mysql_version;
if (node.m_info.m_version < NDBD_SPLIT_VERSION)
node.m_info.m_mysql_version = 0;
if (getMajor(node.m_info.m_version) < getMajor(NDB_VERSION) ||
getMinor(node.m_info.m_version) < getMinor(NDB_VERSION)) {
node.compatible = false;
} else {
node.compatible = true;
}
}
NdbApiSignal signal(numberToRef(API_CLUSTERMGR, theFacade.ownId()));
signal.theVerId_signalNumber = GSN_API_REGCONF;
signal.theReceiversBlockNumber = API_CLUSTERMGR;
signal.theTrace = 0;
signal.theLength = ApiRegConf::SignalLength;
ApiRegConf * const conf = CAST_PTR(ApiRegConf, signal.getDataPtrSend());
conf->qmgrRef = numberToRef(API_CLUSTERMGR, theFacade.ownId());
conf->version = NDB_VERSION;
conf->mysql_version = NDB_MYSQL_VERSION_D;
conf->apiHeartbeatFrequency = cm_node.hbFrequency;
conf->minDbVersion= 0;
conf->nodeState= node.m_state;
node.set_confirmed(true);
if (safe_sendSignal(&signal, nodeId) != 0)
node.set_confirmed(false);
}
void ndbPrintVersion()
{
printf("Version: %u.%u.%u\n",
getMajor(ndbGetOwnVersion()),
getMinor(ndbGetOwnVersion()),
getBuild(ndbGetOwnVersion()));
}
void PackedVersion::print(raw_ostream &OS) const {
OS << format("%d", getMajor());
if (getMinor() || getSubminor())
OS << format(".%d", getMinor());
if (getSubminor())
OS << format(".%d", getSubminor());
}
void getTextConnectedApiVersion(QQQQ) {
BaseString::snprintf(m_text, m_text_len,
"Node %u: API version %d.%d.%d",
theData[1],
getMajor(theData[2]),
getMinor(theData[2]),
getBuild(theData[2]));
}
const char * ndbGetVersionString(Uint32 version, const char * status,
char *buf, unsigned sz)
{
if (status && status[0] != 0)
basestring_snprintf(buf, sz,
"Version %d.%d.%d (%s)",
getMajor(version),
getMinor(version),
getBuild(version),
status);
else
basestring_snprintf(buf, sz,
"Version %d.%d.%d",
getMajor(version),
getMinor(version),
getBuild(version));
return buf;
}
void
MgmApiSession::getVersion(Parser<MgmApiSession>::Context &,
Properties const &) {
m_output->println("version");
m_output->println("id: %d", NDB_VERSION);
m_output->println("major: %d", getMajor(NDB_VERSION));
m_output->println("minor: %d", getMinor(NDB_VERSION));
m_output->println("string: %s", NDB_VERSION_STRING);
m_output->println("");
}
void getTextNDBStartStarted(QQQQ) {
//-----------------------------------------------------------------------
// Start of NDB has been initiated.
//-----------------------------------------------------------------------
BaseString::snprintf(m_text, m_text_len,
"Start initiated (version %d.%d.%d)",
getMajor(theData[1]),
getMinor(theData[1]),
getBuild(theData[1]));
}
bool
BackupRestore::table(const TableS & table){
if (!m_restore && !m_restore_meta)
return true;
const char * name = table.getTableName();
/**
* Ignore blob tables
*/
if(match_blob(name) >= 0)
return true;
const NdbTableImpl & tmptab = NdbTableImpl::getImpl(* table.m_dictTable);
if ((int) tmptab.m_indexType != (int) NdbDictionary::Index::Undefined){
m_indexes.push_back(table.m_dictTable);
return true;
}
BaseString tmp(name);
Vector<BaseString> split;
if(tmp.split(split, "/") != 3){
err << "Invalid table name format `" << name << "`" << endl;
return false;
}
m_ndb->setDatabaseName(split[0].c_str());
m_ndb->setSchemaName(split[1].c_str());
NdbDictionary::Dictionary* dict = m_ndb->getDictionary();
if(m_restore_meta)
{
NdbDictionary::Table copy(*table.m_dictTable);
copy.setName(split[2].c_str());
Uint32 id;
if (copy.getTablespace(&id))
{
debug << "Connecting " << name << " to tablespace oldid: " << id << flush;
NdbDictionary::Tablespace* ts = m_tablespaces[id];
debug << " newid: " << ts->getObjectId() << endl;
copy.setTablespace(* ts);
}
if (copy.getDefaultNoPartitionsFlag())
{
/*
Table was defined with default number of partitions. We can restore
it with whatever is the default in this cluster.
We use the max_rows parameter in calculating the default number.
*/
Uint32 no_nodes = m_cluster_connection->no_db_nodes();
copy.setFragmentCount(get_no_fragments(copy.getMaxRows(),
no_nodes));
set_default_nodegroups(©);
}
else
{
/*
Table was defined with specific number of partitions. It should be
restored with the same number of partitions. It will either be
restored in the same node groups as when backup was taken or by
using a node group map supplied to the ndb_restore program.
*/
Uint16 *ng_array = (Uint16*)copy.getFragmentData();
Uint16 no_parts = copy.getFragmentCount();
if (map_nodegroups(ng_array, no_parts))
{
if (translate_frm(©))
{
err << "Create table " << table.getTableName() << " failed: ";
err << "Translate frm error" << endl;
return false;
}
}
copy.setFragmentData((const void *)ng_array, no_parts << 1);
}
/**
* Force of varpart was introduced in 5.1.18, telco 6.1.7 and 6.2.1
* Since default from mysqld is to add force of varpart (disable with
* ROW_FORMAT=FIXED) we force varpart onto tables when they are restored
* from backups taken with older versions. This will be wrong if
* ROW_FORMAT=FIXED was used on original table, however the likelyhood of
* this is low, since ROW_FORMAT= was a NOOP in older versions.
*/
if (table.getBackupVersion() < MAKE_VERSION(5,1,18))
copy.setForceVarPart(true);
else if (getMajor(table.getBackupVersion()) == 6 &&
(table.getBackupVersion() < MAKE_VERSION(6,1,7) ||
table.getBackupVersion() == MAKE_VERSION(6,2,0)))
copy.setForceVarPart(true);
/*
update min and max rows to reflect the table, this to
ensure that memory is allocated properly in the ndb kernel
*/
copy.setMinRows(table.getNoOfRecords());
if (table.getNoOfRecords() > copy.getMaxRows())
{
copy.setMaxRows(table.getNoOfRecords());
}
NdbTableImpl &tableImpl = NdbTableImpl::getImpl(copy);
if (table.getBackupVersion() < MAKE_VERSION(5,1,0) && !m_no_upgrade){
for(int i= 0; i < copy.getNoOfColumns(); i++)
{
NdbDictionary::Column::Type t = copy.getColumn(i)->getType();
if (t == NdbDictionary::Column::Varchar ||
t == NdbDictionary::Column::Varbinary)
tableImpl.getColumn(i)->setArrayType(NdbDictionary::Column::ArrayTypeShortVar);
if (t == NdbDictionary::Column::Longvarchar ||
t == NdbDictionary::Column::Longvarbinary)
tableImpl.getColumn(i)->setArrayType(NdbDictionary::Column::ArrayTypeMediumVar);
}
}
if (dict->createTable(copy) == -1)
{
err << "Create table `" << table.getTableName() << "` failed: "
<< dict->getNdbError() << endl;
if (dict->getNdbError().code == 771)
{
/*
The user on the cluster where the backup was created had specified
specific node groups for partitions. Some of these node groups
didn't exist on this cluster. We will warn the user of this and
inform him of his option.
*/
err << "The node groups defined in the table didn't exist in this";
err << " cluster." << endl << "There is an option to use the";
err << " the parameter ndb-nodegroup-map to define a mapping from";
err << endl << "the old nodegroups to new nodegroups" << endl;
}
return false;
}
info << "Successfully restored table `"
<< table.getTableName() << "`" << endl;
}
const NdbDictionary::Table* tab = dict->getTable(split[2].c_str());
if(tab == 0){
err << "Unable to find table: `" << split[2].c_str() << "`" << endl;
return false;
}
if(m_restore_meta)
{
if (tab->getFrmData())
{
// a MySQL Server table is restored, thus an event should be created
BaseString event_name("REPL$");
event_name.append(split[0].c_str());
event_name.append("/");
event_name.append(split[2].c_str());
NdbDictionary::Event my_event(event_name.c_str());
my_event.setTable(*tab);
my_event.addTableEvent(NdbDictionary::Event::TE_ALL);
// add all columns to the event
bool has_blobs = false;
for(int a= 0; a < tab->getNoOfColumns(); a++)
{
my_event.addEventColumn(a);
NdbDictionary::Column::Type t = tab->getColumn(a)->getType();
if (t == NdbDictionary::Column::Blob ||
t == NdbDictionary::Column::Text)
has_blobs = true;
}
if (has_blobs)
my_event.mergeEvents(true);
while ( dict->createEvent(my_event) ) // Add event to database
{
if (dict->getNdbError().classification == NdbError::SchemaObjectExists)
{
info << "Event for table " << table.getTableName()
<< " already exists, removing.\n";
if (!dict->dropEvent(my_event.getName()))
continue;
}
err << "Create table event for " << table.getTableName() << " failed: "
<< dict->getNdbError() << endl;
dict->dropTable(split[2].c_str());
return false;
}
info << "Successfully restored table event " << event_name << endl ;
}
}
const NdbDictionary::Table* null = 0;
m_new_tables.fill(table.m_dictTable->getTableId(), null);
m_new_tables[table.m_dictTable->getTableId()] = tab;
return true;
}
inline
bool
isDrop6(Uint32 version)
{
return (getMajor(version) == 5 && getMinor(version) == 2);
}
int main(){
student_t *head, *newStudent,*temp;
int age,major;
float gpa;
char * name, *name1, cr;
char *msg;
int i;
int answer,data;
head = NULL;
printf("You are now entering the student zone!\n");
answer = menu();
while(answer != 7){
switch (answer) {
case 1:
printf("enter age:\n");
scanf("%d%c",&age,&cr);
printf("enter gpa:\n");
scanf("%f%c",&gpa,&cr);
printf("enter major:\n");
scanf("%d%c",&major,&cr);
printf("enter name:\n");
name = getline();
//printf("length: %d\n",strlen(name));
newStudent = createStudent(age, name,major,gpa);
break;
case 2:
insertStudent(&head,newStudent);
break;
case 3:
printf("enter student name to delete\n");
name1 = getline();
deleteStudent(&head,name1);
free(name1);
break;
case 4:
printf("enter student name to investigate\n");
name1 = getline();
data = dataMenu();
switch (data) {
case 1:
temp = findStudent(head, name1);
if(temp == NULL){
printf("Student %s not found \n",name1);
break;
}
age = getAge( temp);
printf("The age of %s, is %d\n",name1,age);
break;
case 2:
temp = findStudent(head, name1);
if(temp == NULL){
printf("Student %s not found \n",name1);
break;
}
gpa = getGpa( temp);
printf("The gpa of %s, is %f\n",name1,gpa);
break;
case 3:
temp = findStudent(head, name1);
if(temp == NULL){
printf("Student %s not found \n",name1);
break;
}
major = getMajor( temp);
printf("The gpa of %s, is %d\n",name1,major);
break;
default:
break;
}
break;
case 5:
temp = head;
while(temp != NULL){
msg = toString( temp);
printf("%s\n",msg);
temp = temp->link;
}
break;
case 6:
insertStudentRear(&head,newStudent);
break;
default:
break;
}
answer = menu();
}
printf("BYE\n");
return(0);
}
QList<QVariant> Version::toArray()
{
return {getMajor(), getMinor(), getPatch(), getBuild(), getRelease()};
}
