OracleDataAdapter returning incorrect schema information

Question

Hi everyone. I have a very reproducible case where the DataTable schema created by the OracleDataAdapter is incorrect. It is driving me crazy :-).
====================
OracleConnection cnn = new OracleConnection("User ID=XXX;Password=XXX;Data Source=XXX");
cnn.Open();
string strQuery = "CREATE TABLE FOO (a INT, b INT)";
OracleCommand cmdExec = new OracleCommand(strQuery, cnn);
cmdExec.ExecuteNonQuery();
OracleCommand cmdQuery = new OracleCommand("SELECT * FROM FOO", cnn);
OracleDataAdapter adp = new OracleDataAdapter(cmdQuery);
DataTable dtb = new DataTable();
adp.Fill(dtb);
Console.WriteLine("FOO has {0} columns.", dtb.Columns.Count);
for (int i = 0; i < dtb.Columns.Count; i++)
Console.WriteLine("{0}th column's name is {1}.", i, dtb.Columns[ i ].ColumnName);
cmdExec.CommandText = "DROP TABLE FOO";
cmdExec.ExecuteNonQuery();
cmdExec.CommandText = "CREATE TABLE FOO (c INT, d INT, e INT)";
cmdExec.ExecuteNonQuery();
dtb = new DataTable();
adp.Fill(dtb);
Console.WriteLine("FOO has {0} columns.", dtb.Columns.Count);
for (int i = 0; i < dtb.Columns.Count; i++)
Console.WriteLine("{0}th column's name is {1}.", i, dtb.Columns[ i ].ColumnName);
cnn.Close();
Console.ReadLine();
=============================
The console output is:
FOO has 2 columns.
0th column's name is A
1th column's name is B
FOO has 2 columns.
0th column's name is A
1th column's name is B
But it should be:
FOO has 3 columns.
0th column's name is C
1th column's name is D
2th column's name is E
for the second iteration.
What should I do?
-- Matt

Answer 1

I agree with the earlier comment stating '...that the caching is happening inside of the ODP layer rather than a lower layer such as OCI. It looks like the caching is occurring in the m_metaData member of the OracleCommand...'.
It looks like all of the caching is indeed taking place in ODP. However there is in fact two levels of cache taking place in your particular example - at the OracleCommand level but also deep inside ODP.Net there is a static MetaData class which has a private member m_pooler that maintains a metadata cache on a per connection basis. Basically even if the OracleCommand object entry m_metaData is reset values still appear inside the internal pool and so there need to be removed too - this cache is indexed initially through a hash of the connection details and then statement text. This is why even a new OracleCommand object but with same statement text on same connection also returns incorrect information.
Within the OracleReader implementations various calls are made to MetaData.Pooler.Get.. calls to retrieve cached information.
I came across a similar problem (not identical) because we are using the 'alter session set current schema...' command and this causes some problems.
Basically it appears a base assumption has been made that the definition of object will not change at runtime (which you can understand) but in my case it is possible that 'select * from emp' say could be execute from the same connection but relate to different objects because name resolution has been adjust using the 'alter session...' command which is a big problem.
I have written some helper routines which enable the internal caches to be 'managed' although it uses some nasty reflection to accomplish this (using private members directly!). It work successfully in my case and I have done a quick change to your example code (added a single call) and it now works, i.e.
cmdExec.CommandText = "CREATE TABLE FOO (c INT, d INT, e INT)";
cmdExec.ExecuteNonQuery();
OracleMetaDataRemover.Remove(cmdQuery, true);
dtb = new DataTable();
adp.Fill(dtb);
If you use the Remove method above and change true to false you will still receive the problem because although the Command has been cleared the details still remain centrally.
The code which accessed above I include below as is (coded for Oracle 10.1.0.3.01 ODP - it may work on other releases but note this could break in future). Ideally methods are required within ODP to allow cleardown/control of this.
using System;
using System.Reflection;
using System.Collections;
using Oracle.DataAccess.Client;
namespace Oracle.DBUtilities
     /// <summary>
     /// Summary description for OracleMetaDataPoolerCleaner.
     /// </summary>
     public class OracleMetaDataPoolerCleaner
          private static string OracleAssemblyShortName = "Oracle.DataAccess";
          private static string OracleMDType = "Oracle.DataAccess.Client.MetaData";
          private static string OraclePoolerType = "Oracle.DataAccess.Client.Pooler";
          // Fast access pointer to internal hash of information
          private Hashtable PooledItems = null;
          private static OracleMetaDataPoolerCleaner _oracleMetaDataPoolerCleanerInstance = null;
          static readonly object _syncRoot = new object();
          private OracleMetaDataPoolerCleaner()
               Assembly OracleDataAccess = null;
               // Get hold of the Oracle Data Access assembly
               Assembly[] LoadedAssemblyList = AppDomain.CurrentDomain.GetAssemblies();
               for(int i=0; i<LoadedAssemblyList.Length && OracleDataAccess == null; i++)
                    Assembly LoadedAssembly = LoadedAssemblyList;
                    string[] AssemblyNameDetails = LoadedAssembly.FullName.Split(',');
                    if (AssemblyNameDetails[0] == OracleMetaDataPoolerCleaner.OracleAssemblyShortName)
                         OracleDataAccess = LoadedAssembly;
               // Make sure located details
               if (OracleDataAccess != null)
                    // Get access to the MetaData cache details
                    Type OracleMetaData = OracleDataAccess.GetType(OracleMetaDataPoolerCleaner.OracleMDType);
                    if (OracleMetaData != null)
                         // Retrieve static pool item
                         FieldInfo f_Pooler = OracleMetaData.GetField("m_pooler", BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.Static);
                         if (f_Pooler != null)
                              // As we cannot get direct access to the object type assume it is OK
                              object pa = f_Pooler.GetValue(null);
                              if (pa != null)
                                   Type OraclePooler = OracleDataAccess.GetType(OracleMetaDataPoolerCleaner.OraclePoolerType);
                                   if (OraclePooler != null)
                                        FieldInfo f_Pools = OraclePooler.GetField("Pools", BindingFlags.NonPublic|BindingFlags.Instance|BindingFlags.Static);
                                        PooledItems = f_Pools.GetValue(pa) as Hashtable;
                                        if (PooledItems == null)
                                             throw new InvalidOperationException("Unable to initialise metadata cache access...");
          public static OracleMetaDataPoolerCleaner Instance()
               // Make single copy of this item ready for use
               if (_oracleMetaDataPoolerCleanerInstance == null)
                    // Thread safe locking and initialisation - 'double-checked lock'
                    lock(_syncRoot)
                         if (_oracleMetaDataPoolerCleanerInstance == null)
                              _oracleMetaDataPoolerCleanerInstance = new OracleMetaDataPoolerCleaner();
               return _oracleMetaDataPoolerCleanerInstance;
          /// <summary>
          /// Using reflection the process determines the command text
          /// contents of the specified OracleCommand
          /// Note this could simply have been delegated through to the
          /// OracleConnection version using OCommand.Connection
          /// </summary>
          /// <param name="OCommand">OracleCommand object containing command to be retrieved</param>
          /// <returns>Command string located</returns>
          public static string CommandText(OracleCommand OCommand)
               string OracleCommandCommandText = null;
               // Using reflection get direct access to the 'private' member details..
               Type TypeOracleCommand = OCommand.GetType();
               FieldInfo FieldInfoCommandText = TypeOracleCommand.GetField("m_commandText", BindingFlags.NonPublic|BindingFlags.Instance);
               if (FieldInfoCommandText != null)
                    OracleCommandCommandText = FieldInfoCommandText.GetValue(OCommand).ToString();
               return OracleCommandCommandText;
          /// <summary>
          /// Using reflection the process determines the command text
          /// contents of the specified OracleCommand
          /// </summary>
          /// <param name="OReader">OracleDataReader object containing command to be retrieved</param>
          /// <returns>CommandString located</returns>
          public static string CommandText(OracleDataReader OReader)
               string OracleDataReaderCommandText = null;
               // Using reflection get direct access to the 'private' member details..
               Type TypeOracleDataReader = OReader.GetType();
               FieldInfo FieldInfoCommandText = TypeOracleDataReader.GetField("m_commandText", BindingFlags.NonPublic|BindingFlags.Instance);
               if (FieldInfoCommandText != null)
                    OracleDataReaderCommandText = FieldInfoCommandText.GetValue(OReader).ToString();
               return OracleDataReaderCommandText;
          /// <summary>
          /// Using reflection the process determines the hashvalue
          /// specified OracleConnection
          /// </summary>
          /// <param name="OConnection">OracleConnection for which the HashCode is to be retrieved</param>
          /// <returns>HashValue located or -1</returns>
          public static int ConnectionStringHashValue(OracleConnection OConnection)
               int HashValue = -1;
               // Using the Oracle Connection retrieve the hashvalue associated
               // with this connection
               if (OConnection != null)
                    Type TypeOracleConnection = OConnection.GetType();
                    FieldInfo f_ConStrHashCode = TypeOracleConnection.GetField("m_conStrHashCode", BindingFlags.NonPublic|BindingFlags.Instance);
                    if (f_ConStrHashCode != null)
                         HashValue = Int32.Parse(f_ConStrHashCode.GetValue(OConnection).ToString());
               return HashValue;
          /// <summary>
          /// Using reflection the process determines the hashvalue
          /// specified OracleDataReader
          /// </summary>
          /// <param name="OReader">OracleDataReader for which the associated connection HashValue is to be located</param>
          /// <returns>HashValue located or -1</returns>
          public static int ConnectionStringHashValue(OracleDataReader OReader)
               int HashValue = -1;
               // Using reflection get direct access to the 'private' member details..
               Type TypeOracleDataReader = OReader.GetType();
               FieldInfo f_OraConnection = TypeOracleDataReader.GetField("m_connection", BindingFlags.NonPublic|BindingFlags.Instance);
               // Ensure have access to a connection and retrieve has information
               if (f_OraConnection != null)
                    OracleConnection ConnectionValue = f_OraConnection.GetValue(OReader) as OracleConnection;
                    HashValue = OracleMetaDataPoolerCleaner.ConnectionStringHashValue(ConnectionValue);
               // Return the hashvalue information located
               return HashValue;
          /// <summary>
          /// Using reflection the process determines the hashvalue
          /// specified OracleCommand
          /// Note this could simply have been delegated through to the
          /// OracleConnection version using OCommand.Connection
          /// </summary>
          /// <param name="OCommand">OracleCommand for which the associated connection HashValue is to be located</param>
          /// <returns>HashValue located or -1</returns>
          public static int ConnectionStringHashValue(OracleCommand OCommand)
               int HashValue = -1;
               // Using reflection get direct access to the 'private' member details..
               Type TypeOracleCommand = OCommand.GetType();
               FieldInfo f_OraConnection = TypeOracleCommand.GetField("m_connection", BindingFlags.NonPublic|BindingFlags.Instance);
               // Ensure have access to a connection and retrieve has information
               if (f_OraConnection != null)
                    OracleConnection ConnectionValue = f_OraConnection.GetValue(OCommand) as OracleConnection;
                    HashValue = OracleMetaDataPoolerCleaner.ConnectionStringHashValue(ConnectionValue);
               // Return the hashvalue information located
               return HashValue;
          /// <summary>
          /// Using the supplied OracleDataReader internal calls are made
          /// to determine the ConnectionHash and CommandText details which will
          /// then be used to remove the item
          /// </summary>
          /// <param name="OReader">OracleDataReader to be probed to obtain information</param>
          /// <returns>Indicates whether the item was actually removed from the cache or not</returns>
          public bool Remove(OracleDataReader OReader)
               bool Removed = false;
               // Lookup the ConnectionStringHashDetails
               int HashValue = OracleMetaDataPoolerCleaner.ConnectionStringHashValue(OReader);
               if (HashValue != -1)
                    // Lookup the command text and remove details
                    string CommandText = OracleMetaDataPoolerCleaner.CommandText(OReader);
                    // Attempt to remove from the cache
                    Removed = this.Remove(HashValue, CommandText);
               return Removed;
          /// <summary>
          /// Using the supplied OracleCommand internal calls are made
          /// to delegate the call to the OracleConnection version
          /// </summary>
          /// <param name="OCommand">OracleCommand to be probed to obtain information</param>
          /// <returns>Indicates whether the item was actually removed from the cache or not</returns>
          public bool Remove(OracleCommand OCommand)
               // Call into internal other routine
               return this.Remove(OCommand.Connection, OCommand.CommandText);
          /// <summary>
          /// Using the supplied OracleConnection internal calls are made
          /// to determine the ConnectionHash and it uses CommandText details
          /// to remove the item
          /// </summary>
          /// <param name="OConnection">OracleConnection from which the cache object should be removed</param>
          /// <param name="CommandText">CommandText to be removed</param>
          /// <returns>Indicates whether the item was actually removed from the cache or not</returns>
          public bool Remove(OracleConnection OConnection, string CommandText)
               bool Removed = false;
               // Lookup the ConnectionStringHashDetails
               int HashValue = OracleMetaDataPoolerCleaner.ConnectionStringHashValue(OConnection);
               if (HashValue != -1)
                    // Attempt to remove from the cache
                    Removed = this.Remove(HashValue, CommandText);
               return Removed;
          /// <summary>
          /// Routine actually removes the items from the cache if it exists
          /// </summary>
          /// <param name="ConnectionHashValue">ConnectionHash which is used to key into the Pooled items</param>
          /// <param name="CommandText">CommandText to be removed</param>
          /// <returns>Indicates whether the item was actually removed from the cache or not</returns>
          private bool Remove(int ConnectionHashValue, string CommandText)
               bool Removed = true;
               // Retrieve Pooled items for particular hash value
               Hashtable PoolContents = PooledItems[ConnectionHashValue] as Hashtable;
               // Remove item if it is contained
               if (PoolContents.ContainsKey(CommandText))
                    PoolContents.Remove(CommandText);
                    Removed = true;
               return Removed;
     /// <summary>
     /// Summary description for OracleMetaDataRemover.
     /// </summary>
     public class OracleMetaDataRemover
          private OracleMetaDataRemover()
          /// <summary>
          /// Routine which Removes MetaData associated with OracleCommand object
          /// </summary>
          /// <param name="OCommand">OracleCommand to have associated MetaData removed</param>
          /// <returns>Indicates whether the MetaData associated with the OracleCommand was reset</returns>
          public static bool Remove(OracleCommand OCommand)
               bool Removed = false;
               // Retrieve current MetaData values from OCommand
               Type OracleCommandMetaData = OCommand.GetType();
               FieldInfo f_metaData = OracleCommandMetaData.GetField("m_metaData", BindingFlags.NonPublic|BindingFlags.Instance);
               if (f_metaData != null)
                    f_metaData.SetValue(OCommand, null);
                    Removed = true;
               // Indicate Removed from OCommand object
               return Removed;
          /// <summary>
          /// Routine which Removes MetaData associated with OracleCommand object
          /// and allows for the removal of information from the internal cache
          /// </summary>
          /// <param name="OCommand">OracleCommand to have associated MetaData removed</param>
          /// <param name="RemoveFromMetaDataPool">Whether item should be removed from the internal metadata pool too</param></param>
          /// <returns>Indicates whether the MetaData associated with the OracleCommand was reset</returns>
          public static bool Remove(OracleCommand OCommand, bool RemoveFromMetaDataPool)
               bool Removed = false;
               // Remove details from Command
               Removed = Remove(OCommand);
               if (Removed && RemoveFromMetaDataPool)
                    // Remove information form internal cache
                    Removed = OracleMetaDataPoolerCleaner.Instance().Remove(OCommand);
               // Indicated Removed from OCommand and Internal MetaData collection
               return Removed;