databasemetadata.cpp.svn-base

絲路server源碼 Silk Road server source

}

int
DatabaseMetaData::getMaxRowSize()
{
  return this->_getNumeric32
    (SQL_MAX_ROW_SIZE);
}

bool DatabaseMetaData::doesMaxRowSizeIncludeBlobs()
{
  return this->_getStringInfo
    (SQL_MAX_ROW_SIZE_INCLUDES_LONG)==ODBCXX_STRING_CONST("Y");
}

int
DatabaseMetaData::getMaxStatementLength()
{
  return this->_getNumeric32
    (SQL_MAX_STATEMENT_LEN);
}

int
DatabaseMetaData::getMaxTableNameLength()
{
  return this->_getNumeric16
    (SQL_MAX_TABLE_NAME_LEN);
}

int
DatabaseMetaData::getMaxTablesInSelect()
{
  return this->_getNumeric16
    (SQL_MAX_TABLES_IN_SELECT);
}

int
DatabaseMetaData::getMaxUserNameLength()
{
  return this->_getNumeric16
    (SQL_MAX_USER_NAME_LEN);
}


int
DatabaseMetaData::getMaxConnections()
{
  return (int)this->_getNumeric16
    (ODBC3_C(SQL_MAX_DRIVER_CONNECTIONS,SQL_ACTIVE_CONNECTIONS));
}


int
DatabaseMetaData::getMaxStatements()
{
  return (int)this->_getNumeric16
    (ODBC3_C(SQL_MAX_CONCURRENT_ACTIVITIES,SQL_ACTIVE_STATEMENTS));
}



bool DatabaseMetaData::supportsMultipleTransactions()
{
  return this->_getStringInfo(SQL_MULTIPLE_ACTIVE_TXN)==ODBCXX_STRING_CONST("Y");
}


bool DatabaseMetaData::supportsOrderByUnrelated()
{
  return this->_getStringInfo(SQL_ORDER_BY_COLUMNS_IN_SELECT)!=ODBCXX_STRING_CONST("Y");
}



bool DatabaseMetaData::supportsDifferentTableCorrelationNames()
{
  return this->_getNumeric16
    (SQL_CORRELATION_NAME)==SQL_CN_DIFFERENT;
}

bool DatabaseMetaData::supportsConvert()
{
  return (this->_getNumeric32
	  (SQL_CONVERT_FUNCTIONS)&SQL_FN_CVT_CONVERT)!=0;
}

bool DatabaseMetaData::supportsConvert(int fromType,
				       int toType)
{
  static const int numTypes=19;

  static struct {
    int id;
    int value;
  } convertMap[numTypes] = {
    { Types::BIGINT, SQL_CONVERT_BIGINT },
    { Types::BINARY, SQL_CONVERT_BINARY },
    { Types::BIT, SQL_CONVERT_BIT },
    { Types::CHAR, SQL_CONVERT_CHAR },
    { Types::DATE, SQL_CONVERT_DATE },
    { Types::DECIMAL, SQL_CONVERT_DECIMAL },
    { Types::DOUBLE, SQL_CONVERT_DOUBLE },
    { Types::FLOAT, SQL_CONVERT_FLOAT },
    { Types::INTEGER, SQL_CONVERT_INTEGER },
    { Types::LONGVARBINARY, SQL_CONVERT_LONGVARBINARY },
    { Types::LONGVARCHAR, SQL_CONVERT_LONGVARCHAR },
    { Types::NUMERIC, SQL_CONVERT_NUMERIC },
    { Types::REAL, SQL_CONVERT_REAL },
    { Types::SMALLINT, SQL_CONVERT_SMALLINT },
    { Types::TIME, SQL_CONVERT_TIME },
    { Types::TIMESTAMP, SQL_CONVERT_TIMESTAMP },
    { Types::TINYINT, SQL_CONVERT_TINYINT },
    { Types::VARBINARY, SQL_CONVERT_VARBINARY },
    { Types::VARCHAR, SQL_CONVERT_VARCHAR }
  };

  static struct {
    int id;
    int value;
  } cvtMap[numTypes] = {
    { Types::BIGINT, SQL_CVT_BIGINT },
    { Types::BINARY, SQL_CVT_BINARY },
    { Types::BIT, SQL_CVT_BIT },
    { Types::CHAR, SQL_CVT_CHAR },
    { Types::DATE, SQL_CVT_DATE },
    { Types::DECIMAL, SQL_CVT_DECIMAL },
    { Types::DOUBLE, SQL_CVT_DOUBLE },
    { Types::FLOAT, SQL_CVT_FLOAT },
    { Types::INTEGER, SQL_CVT_INTEGER },
    { Types::LONGVARBINARY, SQL_CVT_LONGVARBINARY },
    { Types::LONGVARCHAR, SQL_CVT_LONGVARCHAR },
    { Types::NUMERIC, SQL_CVT_NUMERIC },
    { Types::REAL, SQL_CVT_REAL },
    { Types::SMALLINT, SQL_CVT_SMALLINT },
    { Types::TIME, SQL_CVT_TIME },
    { Types::TIMESTAMP, SQL_CVT_TIMESTAMP },
    { Types::TINYINT, SQL_CVT_TINYINT },
    { Types::VARBINARY, SQL_CVT_VARBINARY },
    { Types::VARCHAR, SQL_CVT_VARCHAR }
  };

  for(int i=0; i<numTypes; i++) {
    if(convertMap[i].value==fromType) {
      for(int j=0; j<numTypes; j++) {
	if(cvtMap[j].value==toType) {
	  return (this->_getNumeric32
		  (convertMap[i].value)&cvtMap[i].value)!=0;
	}
      }
      throw SQLException
	(ODBCXX_STRING_CONST("[libodbc++]: supportsConvert(): Unknown toType ")+
	 intToString(toType));
    }
  }
  throw SQLException
    (ODBCXX_STRING_CONST("[libodbc++]: supportsConvert(): Unknown fromType ")+
     intToString(fromType));

  ODBCXX_DUMMY_RETURN(false);
}


bool DatabaseMetaData::storesLowerCaseIdentifiers()
{
  return this->_getNumeric16
    (SQL_IDENTIFIER_CASE)==SQL_IC_LOWER;
}


bool DatabaseMetaData::storesLowerCaseQuotedIdentifiers()
{
  return this->_getNumeric16
    (SQL_QUOTED_IDENTIFIER_CASE)==SQL_IC_LOWER;
}


bool DatabaseMetaData::storesMixedCaseIdentifiers()
{
  return this->_getNumeric16
    (SQL_IDENTIFIER_CASE)==SQL_IC_MIXED;
}


bool DatabaseMetaData::storesMixedCaseQuotedIdentifiers()
{
  return this->_getNumeric16
    (SQL_QUOTED_IDENTIFIER_CASE)==SQL_IC_MIXED;
}


bool DatabaseMetaData::storesUpperCaseIdentifiers()
{
  return this->_getNumeric16
    (SQL_IDENTIFIER_CASE)==SQL_IC_UPPER;
}


bool DatabaseMetaData::storesUpperCaseQuotedIdentifiers()
{
  return this->_getNumeric16
    (SQL_QUOTED_IDENTIFIER_CASE)==SQL_IC_UPPER;
}


bool DatabaseMetaData::supportsMixedCaseIdentifiers()
{
  return this->_getNumeric16
    (SQL_IDENTIFIER_CASE)==SQL_IC_SENSITIVE;
}

bool DatabaseMetaData::supportsMixedCaseQuotedIdentifiers()
{
  return this->_getNumeric16
    (SQL_QUOTED_IDENTIFIER_CASE)==SQL_IC_SENSITIVE;
}


bool DatabaseMetaData::supportsStoredProcedures()
{
  return this->_getStringInfo(SQL_PROCEDURES)==ODBCXX_STRING_CONST("Y");
}

bool DatabaseMetaData::_ownXXXAreVisible(int type, int what)
{
  int odbcType=getODBCCursorTypeFor(type,this->_getDriverInfo());

#if ODBCVER >= 0x0300
  if(this->_getDriverInfo()->getMajorVersion()>2) {
    SQLUINTEGER r=this->_getNumeric32
      (getCursorAttributes2For(odbcType));

    switch(what) {
    case UPDATES:
      return (r&SQL_CA2_SENSITIVITY_UPDATES)!=0;
    case INSERTS:
      return (r&SQL_CA2_SENSITIVITY_ADDITIONS)!=0;
    case DELETES:
      return (r&SQL_CA2_SENSITIVITY_DELETIONS)!=0;
    }
    //notreached
    assert(false);
  }
#endif

  // for odbc 2, assume false for forward only, true for dynamic
  // and check for static and keyset driven

  switch(odbcType) {
  case SQL_CURSOR_FORWARD_ONLY:
    return false;

  case SQL_CURSOR_DYNAMIC:
    return true;

  case SQL_CURSOR_KEYSET_DRIVEN:
  case SQL_CURSOR_STATIC:
    {
      SQLUINTEGER r=this->_getNumeric32(SQL_STATIC_SENSITIVITY);
      switch(what) {
      case UPDATES:
	return (r&SQL_SS_UPDATES)!=0;
      case INSERTS:
	return (r&SQL_SS_ADDITIONS)!=0;
      case DELETES:
	return (r&SQL_SS_DELETIONS)!=0;
      }
    }
  }

  // notreached
  assert(false);
  ODBCXX_DUMMY_RETURN(false);
}

bool DatabaseMetaData::ownUpdatesAreVisible(int type)
{
  return this->_ownXXXAreVisible(type,UPDATES);
}

bool DatabaseMetaData::ownDeletesAreVisible(int type)
{
  return this->_ownXXXAreVisible(type,DELETES);
}

bool DatabaseMetaData::ownInsertsAreVisible(int type)
{
  return this->_ownXXXAreVisible(type,INSERTS);
}

// If I get this correct, the next 3 methods are only
// true when we're using a dynamic cursor

bool DatabaseMetaData::othersUpdatesAreVisible(int type)
{
  int ct=getODBCCursorTypeFor(type,this->_getDriverInfo());
  return ct==SQL_CURSOR_DYNAMIC;
}

bool DatabaseMetaData::othersInsertsAreVisible(int type)
{
  int ct=getODBCCursorTypeFor(type,this->_getDriverInfo());
  return ct==SQL_CURSOR_DYNAMIC;
}

bool DatabaseMetaData::othersDeletesAreVisible(int type)
{
  int ct=getODBCCursorTypeFor(type,this->_getDriverInfo());
  return ct==SQL_CURSOR_DYNAMIC;
}

bool DatabaseMetaData::deletesAreDetected(int type)
{
  return (type!=ResultSet::TYPE_FORWARD_ONLY &&
	  !this->ownDeletesAreVisible(type));
}

bool DatabaseMetaData::insertsAreDetected(int type)
{
  return (type!=ResultSet::TYPE_FORWARD_ONLY &&
	  this->ownInsertsAreVisible(type));
}

bool DatabaseMetaData::updatesAreDetected(int type)
{
  return (type!=ResultSet::TYPE_FORWARD_ONLY);
}


//catalog stuff - actually implemented in Statement
ResultSet* DatabaseMetaData::getTypeInfo()
{
  Statement* stmt=connection_->createStatement();

  try {
    return stmt->_getTypeInfo();
  } catch(...) {
    delete stmt;
    throw;
  }
}

ResultSet* DatabaseMetaData::getTables(const ODBCXX_STRING& catalog,
				       const ODBCXX_STRING& schemaPattern,
				       const ODBCXX_STRING& tableNamePattern,
				       const vector<ODBCXX_STRING>& types)
{
  ODBCXX_STRING typesStr;
  for(unsigned int i=0; i<types.size(); i++) {
    if(i>0) {
      typesStr+=ODBCXX_STRING_CONST(",");
    }
    typesStr+=types[i];
  }

  Statement* stmt=connection_->createStatement();
  try {
    return stmt->_getTables(catalog,
			    schemaPattern,
			    tableNamePattern,
			    typesStr);
  } catch(...) {
    delete stmt;
    throw;
  }
}

ResultSet* DatabaseMetaData::getColumns(const ODBCXX_STRING& catalog,
					const ODBCXX_STRING& schemaPattern,
					const ODBCXX_STRING& tableNamePattern,
					const ODBCXX_STRING& columnNamePattern)
{
  Statement* stmt=connection_->createStatement();
  try {
    return stmt->_getColumns(catalog,
			     schemaPattern,
			     tableNamePattern,
			     columnNamePattern);
  } catch(...) {
    delete stmt;
    throw;
  }
}

ResultSet* DatabaseMetaData::getTablePrivileges(const ODBCXX_STRING& catalog,
						const ODBCXX_STRING& schemaPattern,
						const ODBCXX_STRING& tableNamePattern)
{
  Statement* stmt=connection_->createStatement();
  try {
    return stmt->_getTablePrivileges(catalog,
				     schemaPattern,
				     tableNamePattern);
  } catch(...) {
    delete stmt;
    throw;
  }
}

ResultSet* DatabaseMetaData::getColumnPrivileges(const ODBCXX_STRING& catalog,
						 const ODBCXX_STRING& schemaPattern,
						 const ODBCXX_STRING& tableNamePattern,
						 const ODBCXX_STRING& columnNamePattern)
{
  Statement* stmt=connection_->createStatement();
  try {
    return stmt->_getColumnPrivileges(catalog,
				      schemaPattern,
				      tableNamePattern,
				      columnNamePattern);
  } catch(...) {
    delete stmt;
    throw;
  }
}


ResultSet* DatabaseMetaData::getPrimaryKeys(const ODBCXX_STRING& catalog,
					    const ODBCXX_STRING& schema,
					    const ODBCXX_STRING& table)
{
  Statement* stmt=connection_->createStatement();

  try {
    return stmt->_getPrimaryKeys(catalog,
				 schema,
				 table);
  } catch(...) {
    delete stmt;
    throw;
  }
}


ResultSet* DatabaseMetaData::getCrossReference(const ODBCXX_STRING& primaryCatalog,
					       const ODBCXX_STRING& primarySchema,
					       const ODBCXX_STRING& primaryTable,
					       const ODBCXX_STRING& foreignCatalog,
					       const ODBCXX_STRING& foreignSchema,
					       const ODBCXX_STRING& foreignTable)
{
  Statement* stmt=connection_->createStatement();

  try {
    return stmt->_getCrossReference(primaryCatalog,
				    primarySchema,
				    primaryTable,
				    foreignCatalog,
				    foreignSchema,
				    foreignTable);
  } catch(...) {
    delete stmt;
    throw;
  }
}



ResultSet* DatabaseMetaData::getTableTypes()
{
  Statement* stmt=connection_->createStatement();
  try {
    return stmt->_getTables(ODBCXX_STRING_CONST(""),
                            ODBCXX_STRING_CONST(""),
                            ODBCXX_STRING_CONST(""),
                            ODBCXX_STRING_CONST("%"));
  } catch(...) {
    delete stmt;
    throw;
  }
}


ResultSet* DatabaseMetaData::getSchemas()
{
  Statement* stmt=connection_->createStatement();
  try {
    return stmt->_getTables(ODBCXX_STRING_CONST(""),
                            ODBCXX_STRING_CONST("%"),
                            ODBCXX_STRING_CONST(""),
                            ODBCXX_STRING_CONST(""));
  } catch(...) {
    delete stmt;
    throw;
  }
}


ResultSet* DatabaseMetaData::getCatalogs()
{
  Statement* stmt=connection_->createStatement();

  try {
    return stmt->_getTables(ODBCXX_STRING_CONST("%"),
                            ODBCXX_STRING_CONST(""),
                            ODBCXX_STRING_CONST(""),
                            ODBCXX_STRING_CONST(""));
  } catch(...) {
    delete stmt;
    throw;
  }
}


ResultSet* DatabaseMetaData::getIndexInfo(const ODBCXX_STRING& catalog,
					  const ODBCXX_STRING& schemaPattern,
					  const ODBCXX_STRING& tableNamePattern,
					  bool unique, bool accurate)
{
  Statement* stmt=connection_->createStatement();

  try {
    return stmt->_getIndexInfo(catalog,schemaPattern,tableNamePattern,
			       unique,accurate);
  } catch(...) {
    delete stmt;
    throw;
  }
}


ResultSet* DatabaseMetaData::getProcedures(const ODBCXX_STRING& catalog,
					   const ODBCXX_STRING& schemaPattern,
					   const ODBCXX_STRING& procedureNamePattern)
{
  Statement* stmt=connection_->createStatement();
  try {
    return stmt->_getProcedures(catalog,schemaPattern,procedureNamePattern);
  } catch(...) {
    delete stmt;
    throw;
  }
}


ResultSet* DatabaseMetaData::getProcedureColumns(const ODBCXX_STRING& catalog,
						 const ODBCXX_STRING& schemaPattern,
						 const ODBCXX_STRING& procedureNamePattern,
						 const ODBCXX_STRING& columnNamePattern)
{
  Statement* stmt=connection_->createStatement();

  try {
    return stmt->_getProcedureColumns(catalog,
				      schemaPattern,
				      procedureNamePattern,
				      columnNamePattern);
  } catch(...) {
    delete stmt;
    throw;
  }
}


ResultSet* DatabaseMetaData::getBestRowIdentifier(const ODBCXX_STRING& catalog,
						  const ODBCXX_STRING& schema,
						  const ODBCXX_STRING& table,
						  int scope,
						  bool nullable)
{
  Statement* stmt=connection_->createStatement();

  try {
    return stmt->_getSpecialColumns(catalog,schema,table,
				    SQL_BEST_ROWID,
				    scope,
				    nullable?SQL_NULLABLE:SQL_NO_NULLS);
  } catch(...) {
    delete stmt;
    throw;
  }
}
						

ResultSet* DatabaseMetaData::getVersionColumns(const ODBCXX_STRING& catalog,
					       const ODBCXX_STRING& schema,
					       const ODBCXX_STRING& table)
{
  Statement* stmt=connection_->createStatement();

  try {
    return stmt->_getSpecialColumns(catalog,schema,table,
				    SQL_ROWVER,SQL_SCOPE_CURROW,
				    SQL_NULLABLE);
  } catch(...) {
    delete stmt;
    throw;
  }
}