isql++.cpp

絲路server源碼 Silk Road server source

      do {
	cout << this->makeIdentifier
	  (tableRs->getString(1),tableRs->getString(2),tableRs->getString(3));
	
	cout << " (" << tableRs->getString(4) << ")" << endl;

	string desc=tableRs->getString(5);
	bool descIsNull=tableRs->wasNull();

	int nameLength=30;
	int nullabilityLength=10;
	int typeLength=25;

	string nameTitle="Column name";
	string nullabilityTitle="Nullable";
	string typeTitle="Data type";
	
	nameTitle.resize(nameLength,SPACE_CHAR);
	typeTitle.resize(typeLength,SPACE_CHAR);
	nullabilityTitle.resize(nullabilityLength,SPACE_CHAR);
	
	cout << OUTER_SEPARATOR << nameTitle
	     << INNER_SEPARATOR << typeTitle
	     << INNER_SEPARATOR << nullabilityTitle
	     << OUTER_SEPARATOR << endl;

	string t;
	cout << OUTER_SEPARATOR;
	t.resize(nameLength,LINE_CHAR);
	cout << t << INNER_SEPARATOR;
	t.resize(typeLength,LINE_CHAR);
	cout << t << INNER_SEPARATOR;
	t.resize(nullabilityLength,LINE_CHAR);
	cout << t << OUTER_SEPARATOR << endl;
	
	//now, fetch the columns
	{
	  ResultSet* rs=md->getColumns
	    (catalog,schema,tableRs->getString(3),"%");
	  Deleter<ResultSet> _rs(rs);
	  
	  while(rs->next()) {
	    cout << OUTER_SEPARATOR;

	    string colName=rs->getString(4);
	    colName.resize(nameLength,SPACE_CHAR);

	    string typeName=rs->getString(6);
	    typeName.resize(typeLength,SPACE_CHAR);
	    
	    string nullInfo;
	    switch(rs->getInt(11)) {
	    case DatabaseMetaData::columnNoNulls:
	      nullInfo="No";
	      break;
	    case DatabaseMetaData::columnNullable:
	      nullInfo="Yes";
	      break;
	    default:
	      nullInfo="Unknown";
	      break;
	    }

	    nullInfo.resize(nullabilityLength);
	    
	    cout << colName << INNER_SEPARATOR
		 << typeName << INNER_SEPARATOR
		 << nullInfo << OUTER_SEPARATOR
		 << endl;
	  }
	}

	cout << endl;

	try {
	  ResultSet* rs=md->getPrimaryKeys(tableRs->getString(1),
					   tableRs->getString(2),
					   tableRs->getString(3));
	  Deleter<ResultSet> _rs(rs);
	  string colNames;
	  string keyName;
	  bool keyNameIsNull=true;
	  if(rs->next()) {
	    try {
	      keyName=rs->getString(6);
	      keyNameIsNull=rs->wasNull();
	    } catch(SQLException&) {} //temporary workaround for OL driver

	    do {
	      if(colNames.length()>0) {
		colNames+=",";
	      }
	      colNames+=rs->getString(4);
	    } while(rs->next());
	  }

	  if(colNames.length()>0) {
	    cout << OUTER_SEPARATOR << "PRIMARY KEY "
		 << "(" << colNames << ")" << endl;
	      
	  }
	} catch(SQLException& e) {
	}

	//fetch the foreign keys
	try {
	  ResultSet* rs=md->getImportedKeys(tableRs->getString(1),
					    tableRs->getString(2),
					    tableRs->getString(3));
	  
	  Deleter<ResultSet> _rs(rs);
	  
	  bool goon=rs->next();
	  // here, we trust that the result set is ordered
	  // by key_seq
	  while(goon) {
	    string pkTable=this->makeIdentifier
	      (rs->getString(1),rs->getString(2),rs->getString(3));

	    string pkCols;
	    string fkCols;
	    short ks=rs->getShort(9);
	    
	    pkCols+=rs->getString(4);
	    fkCols+=rs->getString(8);
	    
	    while(goon=rs->next()) {
	      if(rs->getShort(9)==1) {
		//this is part of another key
		break;
	      }
	      
	      pkCols+=",";
	      fkCols+=",";
	      
	      pkCols+=rs->getString(4);
	      fkCols+=rs->getString(8);
	    }
	    
	    cout << OUTER_SEPARATOR << "FOREIGN KEY ("
		 << fkCols << ") REFERENCES " 
		 << pkTable << " (" << pkCols << ")"
		 << OUTER_SEPARATOR << endl;
	  }
	} catch(SQLException& e) {
	  // ignore, probably not supported
	}

	try {
	  ResultSet* rs=md->getIndexInfo(tableRs->getString(1),
					 tableRs->getString(2),
					 tableRs->getString(3),
					 false,false);
	  Deleter<ResultSet> _rs(rs);
	  bool goon=rs->next();

	  while(goon) {
	    //ignore statistics
	    if(rs->getShort(7)==DatabaseMetaData::tableIndexStatistic) {
	      goon=rs->next();
	      break;
	    }
	    
	    string idxName=rs->getString(6);
	    string cols=rs->getString(9);
	    string order=(rs->getString(10)=="A"?"ASC":"DESC");
	    string unique=(rs->getBoolean(4)?"":"UNIQUE ");
	    
	    while(goon=rs->next()) {
	      if(rs->getShort(8)==1) {
		// part of next index
		break;
	      }
	      cols+=","+rs->getString(9);
	    }

	    cout << OUTER_SEPARATOR << unique << order
		 << " INDEX " << idxName << " ON (" << cols << ")" << endl;
	  }
	  

	} catch(SQLException&) {}

	try {
	  ResultSet* rs=md->getBestRowIdentifier(tableRs->getString(1),
						 tableRs->getString(2),
						 tableRs->getString(3),
						 DatabaseMetaData::bestRowTemporary,
						 true);
	  Deleter<ResultSet> _rs(rs);

	  if(rs->next()) {

	    cout << endl;

	    int nameLength=30;
	    int pseudoLength=10;
	    int scopeLength=30;

	    string nameTitle="Column name";
	    string pseudoTitle="Pseudo";
	    string scopeTitle="Scope";

	    cout << OUTER_SEPARATOR << "Best row identifiers" << endl;
	
	    nameTitle.resize(nameLength,SPACE_CHAR);
	    pseudoTitle.resize(pseudoLength,SPACE_CHAR);
	    scopeTitle.resize(scopeLength,SPACE_CHAR);
	
	    cout << OUTER_SEPARATOR << nameTitle
		 << INNER_SEPARATOR << pseudoTitle
		 << INNER_SEPARATOR << scopeTitle
		 << OUTER_SEPARATOR << endl;
	    
	    string t;
	    cout << OUTER_SEPARATOR;
	    t.resize(nameLength,LINE_CHAR);
	    cout << t << INNER_SEPARATOR;
	    t.resize(pseudoLength,LINE_CHAR);
	    cout << t << INNER_SEPARATOR;
	    t.resize(scopeLength,LINE_CHAR);
	    cout << t << OUTER_SEPARATOR << endl;

	    do {
	      string colName=rs->getString(2);
	      string pseudo;
	      string scope;

	      switch(rs->getInt(8)) {
	      case DatabaseMetaData::bestRowPseudo:
		pseudo="Yes";
		break;
	      case DatabaseMetaData::bestRowNotPseudo:
		pseudo="No";
		break;
	      case DatabaseMetaData::bestRowUnknown:
		pseudo="Unknown";
		break;
	      default:
		pseudo="?";
		break;
	      }

	      switch(rs->getInt(1)) {
	      case DatabaseMetaData::bestRowTemporary:
		scope="While positioned on row";
		break;
	      case DatabaseMetaData::bestRowTransaction:
		scope="Current transaction";
		break;
	      case DatabaseMetaData::bestRowSession:
		scope="Session (across transactions)";
		break;

	      default:
		scope="?";
		break;
	      }

	      colName.resize(nameLength,SPACE_CHAR);
	      pseudo.resize(pseudoLength,SPACE_CHAR);
	      scope.resize(scopeLength,SPACE_CHAR);

	      cout << OUTER_SEPARATOR << colName
		   << INNER_SEPARATOR << pseudo
		   << INNER_SEPARATOR << scope
		   << OUTER_SEPARATOR << endl;

	    } while(rs->next());
	  } 
	} catch(SQLException& e) {
	  // ignore
	}

	cout << endl;
	
	if(!descIsNull && desc.length()>0) {
	  cout << OUTER_SEPARATOR << "Description" << endl;
	  cout << OUTER_SEPARATOR << "===========" << endl;
	  cout << OUTER_SEPARATOR << desc << endl;
	  cout << endl;
	}
      } while(tableRs->next());
    }
  }

  bool wasProcedure=false;

  if(!wasTable) {
    // this might be a procedure
    try {
      ResultSet* procRs=md->getProcedures(catalog,schema,name);
      Deleter<ResultSet> _procRs(procRs);
      
      if(wasProcedure=procRs->next()) {
	do {
	  cout << this->makeIdentifier
	    (procRs->getString(1),procRs->getString(2),procRs->getString(3))
	       << " (PROCEDURE)" << endl;

	  ResultSet* colRs=md->getProcedureColumns(procRs->getString(1),
						   procRs->getString(2),
						   procRs->getString(3),
						   "%");
	  Deleter<ResultSet> _colRs(colRs);

	  if(colRs->next()) {
	    int nameLen=30;
	    int dataTypeLen=15;
	    int nullableLen=8;
	    int typeLen=10;

	    string nameTitle="Column";
	    string dataTypeTitle="Data type";
	    string nullableTitle="Nullable";
	    string typeTitle="Type";

	    nameTitle.resize(nameLen,SPACE_CHAR);
	    dataTypeTitle.resize(dataTypeLen,SPACE_CHAR);
	    nullableTitle.resize(nullableLen);
	    typeTitle.resize(typeLen);
	    
	    cout << OUTER_SEPARATOR << nameTitle
		 << INNER_SEPARATOR << dataTypeTitle
		 << INNER_SEPARATOR << nullableTitle
		 << INNER_SEPARATOR << typeTitle
		 << OUTER_SEPARATOR << endl;
	    string t;
	    t.resize(nameLen,LINE_CHAR);
	    cout << OUTER_SEPARATOR << t;
	    t.resize(dataTypeLen,LINE_CHAR);
	    cout << INNER_SEPARATOR << t;
	    t.resize(nullableLen,LINE_CHAR);
	    cout << INNER_SEPARATOR << t;
	    t.resize(typeLen,LINE_CHAR);
	    cout << t << OUTER_SEPARATOR << endl;
	    do {
	      string name=colRs->getString(4);
	      string dataType=colRs->getString(7);

	      string nullable;
	      switch(colRs->getShort(12)) {
	      case DatabaseMetaData::procedureNoNulls:
		nullable="No";
		break;
	      case DatabaseMetaData::procedureNullable:
		nullable="Yes";
		break;
	      case DatabaseMetaData::procedureNullableUnknown:
	      default:
		nullable="?";
		break;
	      }
	      
	      string type;
	      switch(colRs->getShort(5)) {
	      case DatabaseMetaData::procedureColumnIn:
		type="IN"; break;
	      case DatabaseMetaData::procedureColumnOut:
		type="OUT"; break;
	      case DatabaseMetaData::procedureColumnInOut:
		type="IN OUT"; break;
	      case DatabaseMetaData::procedureColumnReturn:
		type="RETURN"; break;
	      case DatabaseMetaData::procedureColumnResult:
		type="RESULT"; break;
	      default:
		type="?";
	      }

	      name.resize(nameLen,SPACE_CHAR);
	      dataType.resize(dataTypeLen,SPACE_CHAR);
	      nullable.resize(nullableLen,SPACE_CHAR);
	      type.resize(typeLen,SPACE_CHAR);

	      cout << OUTER_SEPARATOR << name
		   << INNER_SEPARATOR << dataType
		   << INNER_SEPARATOR << nullable
		   << INNER_SEPARATOR << type
		   << OUTER_SEPARATOR << endl;

	    } while(colRs->next());
	  }
	  
	} while(procRs->next());
      }
      
    } catch(SQLException& e) {
      //apparently no procedures
    }
  }

  if(!(wasProcedure || wasTable)) {
    cout << "Could not find any table or procedure named " << arg << endl;
  }
}




int main(int argc, char** argv)
{
  if(argc!=2 && argc!=4) {
    cerr << "Usage: " << argv[0] << " connect-string" << endl
	 << "or     " << argv[0] << " dsn username password" << endl;
    return 0;
  }
  try {
    Connection* con;
    if(argc==2) {
      con=DriverManager::getConnection(argv[1]);
    } else {
      con=DriverManager::getConnection(argv[1],argv[2],argv[3]);
    }

    Deleter<Connection> _con(con);
    DatabaseMetaData* md=con->getMetaData();
    cout << "Connected to " 
	 << md->getDatabaseProductName() << " "
	 << md->getDatabaseProductVersion()
	 << " using " << md->getDriverName() << " "
	 << md->getDriverVersion() << " (ODBC Version "
	 << md->getDriverMajorVersion() << "."
	 << md->getDriverMinorVersion() << ")" << endl;


    {
      Isql isql(con);
      isql.run();
    }

    cout << endl;
  } catch(SQLException& e) {
    cerr << endl << "Whoops: " << e.getMessage() << endl;
    return 1;
  }

  return 0;
}