You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@ibatis.apache.org by "Ron Grabowski (JIRA)" <ib...@incubator.apache.org> on 2005/08/06 10:01:36 UTC

[jira] Created: (IBATISNET-100) Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized

Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized
--------------------------------------------------------------------------------------------

         Key: IBATISNET-100
         URL: http://issues.apache.org/jira/browse/IBATISNET-100
     Project: iBatis for .NET
        Type: Improvement
  Components: DataMapper  
    Reporter: Ron Grabowski
    Priority: Minor


I've extracted all of my cacheModel and resultMap nodes to a seperate xml files:

 /SqlMaps/CacheModels.xml
 /SqlMaps/ResultMaps.xml
 /SqlMaps/OleDb/...
 /SqlMaps/MySQL/...
 /SqlMaps/SqlServer/...

to avoid duplicating nodes in database specific files. The database specific files are a lot cleaner becuase they only contain <statement> nodes.

The current implementation of ConfigureSqlMap() in DomSqlMapBuilder.cs calls RegisterTriggerStatement when the cacheModel node is processed. When the cacheModel nodes are in a seperate file, its not possible to register a trigger statement becuase the xml files that contain those statements haven't been processed yet. Delaying the registration of cacheModel to just before the cacheModel is attached to the mapped statement makes it possible to declare the cacheModel nodes without requiring the statements exist yet. 

One of the benefits to being able to keep a seperate file of cacheModel nodes is that you could mark normal sqlMap file as embedded resources while keeping the CacheModel.xml file as a resource on the file system. The CacheModels.xml file can be tweaked without having to recompile the application. 

To accomplish this, 4 changes need to occur:

1)
Change the SqlMap.xsd file to not require a <statements> node. This allows a <sqlMap> node to contain just a <cacheModels> and/or just a <resultMaps> node.

2)
Add a property in ConfigurationScope.cs to keep track of what statements belong to a cacheModel:

 public HybridDictionary CacheModelFlushOnExecuteStatements
 {
 get { return _cacheModelFlushOnExecuteStatements; }
 set { _cacheModelFlushOnExecuteStatements = value; }
 }

I wonder if there is a cleaner way of doing this ???

3)
Replace this code in DomSqlMapBuilder.cs:

 IMappedStatement mappedStatement = _configScope.SqlMapper.GetMappedStatement(statementName);
 cacheModel.RegisterTriggerStatement(mappedStatement);

with:

 IList statementNames = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
 if (statementNames == null)
 {
  statementNames = new ArrayList();
 }
 statementNames.Add(statementName);
 _configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id] = statementNames;

4)
Change this line in DomSqlMapBuilder.cs:

 mappedStatement.Statement.CacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);

to:

 CacheModel cacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
 IList statementsToRegister = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
 if (statementsToRegister != null)
 {
  if (statementsToRegister.Contains(mappedStatement.Name))
  {
  cacheModel.RegisterTriggerStatement(mappedStatement);
  }
  else
  {
  // TODO: alert user
  }
 }
 mappedStatement.Statement.CacheModel = cacheModel;

Do other people think this would be useful? It would certinally make files that contain <statement> nodes a lot cleaner and eliminate to duplication of <cacheModels> and <resultMaps> node across files.

- Ron

-- 
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
   http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
   http://www.atlassian.com/software/jira


[jira] Commented: (IBATISNET-100) Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized

Posted by "Ron Grabowski (JIRA)" <ib...@incubator.apache.org>.
    [ http://issues.apache.org/jira/browse/IBATISNET-100?page=comments#action_12322682 ] 

Ron Grabowski commented on IBATISNET-100:
-----------------------------------------

Fixed in 278826.

I think the name of CacheModelFlushOnExecuteStatements needs to be changed to something else. I couldn't think of a better name...


> Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized
> --------------------------------------------------------------------------------------------
>
>          Key: IBATISNET-100
>          URL: http://issues.apache.org/jira/browse/IBATISNET-100
>      Project: iBatis for .NET
>         Type: Improvement
>   Components: DataMapper
>     Reporter: Ron Grabowski
>     Assignee: Ron Grabowski
>     Priority: Minor
>  Attachments: DomSqlMapBuilder.patch
>
> I've extracted all of my cacheModel and resultMap nodes to a seperate xml files:
>  /SqlMaps/CacheModels.xml
>  /SqlMaps/ResultMaps.xml
>  /SqlMaps/OleDb/...
>  /SqlMaps/MySQL/...
>  /SqlMaps/SqlServer/...
> to avoid duplicating nodes in database specific files. The database specific files are a lot cleaner becuase they only contain <statement> nodes.
> The current implementation of ConfigureSqlMap() in DomSqlMapBuilder.cs calls RegisterTriggerStatement when the cacheModel node is processed. When the cacheModel nodes are in a seperate file, its not possible to register a trigger statement becuase the xml files that contain those statements haven't been processed yet. Delaying the registration of cacheModel to just before the cacheModel is attached to the mapped statement makes it possible to declare the cacheModel nodes without requiring the statements exist yet. 
> One of the benefits to being able to keep a seperate file of cacheModel nodes is that you could mark normal sqlMap file as embedded resources while keeping the CacheModel.xml file as a resource on the file system. The CacheModels.xml file can be tweaked without having to recompile the application. 
> To accomplish this, 4 changes need to occur:
> 1)
> Change the SqlMap.xsd file to not require a <statements> node. This allows a <sqlMap> node to contain just a <cacheModels> and/or just a <resultMaps> node.
> 2)
> Add a property in ConfigurationScope.cs to keep track of what statements belong to a cacheModel:
>  public HybridDictionary CacheModelFlushOnExecuteStatements
>  {
>  get { return _cacheModelFlushOnExecuteStatements; }
>  set { _cacheModelFlushOnExecuteStatements = value; }
>  }
> I wonder if there is a cleaner way of doing this ???
> 3)
> Replace this code in DomSqlMapBuilder.cs:
>  IMappedStatement mappedStatement = _configScope.SqlMapper.GetMappedStatement(statementName);
>  cacheModel.RegisterTriggerStatement(mappedStatement);
> with:
>  IList statementNames = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementNames == null)
>  {
>   statementNames = new ArrayList();
>  }
>  statementNames.Add(statementName);
>  _configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id] = statementNames;
> 4)
> Change this line in DomSqlMapBuilder.cs:
>  mappedStatement.Statement.CacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
> to:
>  CacheModel cacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
>  IList statementsToRegister = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementsToRegister != null)
>  {
>   if (statementsToRegister.Contains(mappedStatement.Name))
>   {
>   cacheModel.RegisterTriggerStatement(mappedStatement);
>   }
>   else
>   {
>   // TODO: alert user
>   }
>  }
>  mappedStatement.Statement.CacheModel = cacheModel;
> Do other people think this would be useful? It would certinally make files that contain <statement> nodes a lot cleaner and eliminate to duplication of <cacheModels> and <resultMaps> node across files.
> - Ron

-- 
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
   http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
   http://www.atlassian.com/software/jira


[jira] Resolved: (IBATISNET-100) Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized

Posted by "Ron Grabowski (JIRA)" <ib...@incubator.apache.org>.
     [ http://issues.apache.org/jira/browse/IBATISNET-100?page=all ]
     
Ron Grabowski resolved IBATISNET-100:
-------------------------------------

    Resolution: Fixed

> Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized
> --------------------------------------------------------------------------------------------
>
>          Key: IBATISNET-100
>          URL: http://issues.apache.org/jira/browse/IBATISNET-100
>      Project: iBatis for .NET
>         Type: Improvement
>   Components: DataMapper
>     Reporter: Ron Grabowski
>     Assignee: Ron Grabowski
>     Priority: Minor
>  Attachments: DomSqlMapBuilder.patch
>
> I've extracted all of my cacheModel and resultMap nodes to a seperate xml files:
>  /SqlMaps/CacheModels.xml
>  /SqlMaps/ResultMaps.xml
>  /SqlMaps/OleDb/...
>  /SqlMaps/MySQL/...
>  /SqlMaps/SqlServer/...
> to avoid duplicating nodes in database specific files. The database specific files are a lot cleaner becuase they only contain <statement> nodes.
> The current implementation of ConfigureSqlMap() in DomSqlMapBuilder.cs calls RegisterTriggerStatement when the cacheModel node is processed. When the cacheModel nodes are in a seperate file, its not possible to register a trigger statement becuase the xml files that contain those statements haven't been processed yet. Delaying the registration of cacheModel to just before the cacheModel is attached to the mapped statement makes it possible to declare the cacheModel nodes without requiring the statements exist yet. 
> One of the benefits to being able to keep a seperate file of cacheModel nodes is that you could mark normal sqlMap file as embedded resources while keeping the CacheModel.xml file as a resource on the file system. The CacheModels.xml file can be tweaked without having to recompile the application. 
> To accomplish this, 4 changes need to occur:
> 1)
> Change the SqlMap.xsd file to not require a <statements> node. This allows a <sqlMap> node to contain just a <cacheModels> and/or just a <resultMaps> node.
> 2)
> Add a property in ConfigurationScope.cs to keep track of what statements belong to a cacheModel:
>  public HybridDictionary CacheModelFlushOnExecuteStatements
>  {
>  get { return _cacheModelFlushOnExecuteStatements; }
>  set { _cacheModelFlushOnExecuteStatements = value; }
>  }
> I wonder if there is a cleaner way of doing this ???
> 3)
> Replace this code in DomSqlMapBuilder.cs:
>  IMappedStatement mappedStatement = _configScope.SqlMapper.GetMappedStatement(statementName);
>  cacheModel.RegisterTriggerStatement(mappedStatement);
> with:
>  IList statementNames = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementNames == null)
>  {
>   statementNames = new ArrayList();
>  }
>  statementNames.Add(statementName);
>  _configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id] = statementNames;
> 4)
> Change this line in DomSqlMapBuilder.cs:
>  mappedStatement.Statement.CacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
> to:
>  CacheModel cacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
>  IList statementsToRegister = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementsToRegister != null)
>  {
>   if (statementsToRegister.Contains(mappedStatement.Name))
>   {
>   cacheModel.RegisterTriggerStatement(mappedStatement);
>   }
>   else
>   {
>   // TODO: alert user
>   }
>  }
>  mappedStatement.Statement.CacheModel = cacheModel;
> Do other people think this would be useful? It would certinally make files that contain <statement> nodes a lot cleaner and eliminate to duplication of <cacheModels> and <resultMaps> node across files.
> - Ron

-- 
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
   http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
   http://www.atlassian.com/software/jira


[jira] Assigned: (IBATISNET-100) Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized

Posted by "Gilles Bayon (JIRA)" <ib...@incubator.apache.org>.
     [ http://issues.apache.org/jira/browse/IBATISNET-100?page=all ]

Gilles Bayon reassigned IBATISNET-100:
--------------------------------------

    Assign To: Ron Grabowski

Could you apply your patch Ron ?

> Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized
> --------------------------------------------------------------------------------------------
>
>          Key: IBATISNET-100
>          URL: http://issues.apache.org/jira/browse/IBATISNET-100
>      Project: iBatis for .NET
>         Type: Improvement
>   Components: DataMapper
>     Reporter: Ron Grabowski
>     Assignee: Ron Grabowski
>     Priority: Minor
>  Attachments: DomSqlMapBuilder.patch
>
> I've extracted all of my cacheModel and resultMap nodes to a seperate xml files:
>  /SqlMaps/CacheModels.xml
>  /SqlMaps/ResultMaps.xml
>  /SqlMaps/OleDb/...
>  /SqlMaps/MySQL/...
>  /SqlMaps/SqlServer/...
> to avoid duplicating nodes in database specific files. The database specific files are a lot cleaner becuase they only contain <statement> nodes.
> The current implementation of ConfigureSqlMap() in DomSqlMapBuilder.cs calls RegisterTriggerStatement when the cacheModel node is processed. When the cacheModel nodes are in a seperate file, its not possible to register a trigger statement becuase the xml files that contain those statements haven't been processed yet. Delaying the registration of cacheModel to just before the cacheModel is attached to the mapped statement makes it possible to declare the cacheModel nodes without requiring the statements exist yet. 
> One of the benefits to being able to keep a seperate file of cacheModel nodes is that you could mark normal sqlMap file as embedded resources while keeping the CacheModel.xml file as a resource on the file system. The CacheModels.xml file can be tweaked without having to recompile the application. 
> To accomplish this, 4 changes need to occur:
> 1)
> Change the SqlMap.xsd file to not require a <statements> node. This allows a <sqlMap> node to contain just a <cacheModels> and/or just a <resultMaps> node.
> 2)
> Add a property in ConfigurationScope.cs to keep track of what statements belong to a cacheModel:
>  public HybridDictionary CacheModelFlushOnExecuteStatements
>  {
>  get { return _cacheModelFlushOnExecuteStatements; }
>  set { _cacheModelFlushOnExecuteStatements = value; }
>  }
> I wonder if there is a cleaner way of doing this ???
> 3)
> Replace this code in DomSqlMapBuilder.cs:
>  IMappedStatement mappedStatement = _configScope.SqlMapper.GetMappedStatement(statementName);
>  cacheModel.RegisterTriggerStatement(mappedStatement);
> with:
>  IList statementNames = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementNames == null)
>  {
>   statementNames = new ArrayList();
>  }
>  statementNames.Add(statementName);
>  _configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id] = statementNames;
> 4)
> Change this line in DomSqlMapBuilder.cs:
>  mappedStatement.Statement.CacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
> to:
>  CacheModel cacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
>  IList statementsToRegister = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementsToRegister != null)
>  {
>   if (statementsToRegister.Contains(mappedStatement.Name))
>   {
>   cacheModel.RegisterTriggerStatement(mappedStatement);
>   }
>   else
>   {
>   // TODO: alert user
>   }
>  }
>  mappedStatement.Statement.CacheModel = cacheModel;
> Do other people think this would be useful? It would certinally make files that contain <statement> nodes a lot cleaner and eliminate to duplication of <cacheModels> and <resultMaps> node across files.
> - Ron

-- 
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
   http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
   http://www.atlassian.com/software/jira


[jira] Closed: (IBATISNET-100) Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized

Posted by "Gilles Bayon (JIRA)" <ib...@incubator.apache.org>.
     [ http://issues.apache.org/jira/browse/IBATISNET-100?page=all ]
     
Gilles Bayon closed IBATISNET-100:
----------------------------------


> Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized
> --------------------------------------------------------------------------------------------
>
>          Key: IBATISNET-100
>          URL: http://issues.apache.org/jira/browse/IBATISNET-100
>      Project: iBatis for .NET
>         Type: Improvement
>   Components: DataMapper
>     Reporter: Ron Grabowski
>     Assignee: Ron Grabowski
>     Priority: Minor
>  Attachments: DomSqlMapBuilder.patch
>
> I've extracted all of my cacheModel and resultMap nodes to a seperate xml files:
>  /SqlMaps/CacheModels.xml
>  /SqlMaps/ResultMaps.xml
>  /SqlMaps/OleDb/...
>  /SqlMaps/MySQL/...
>  /SqlMaps/SqlServer/...
> to avoid duplicating nodes in database specific files. The database specific files are a lot cleaner becuase they only contain <statement> nodes.
> The current implementation of ConfigureSqlMap() in DomSqlMapBuilder.cs calls RegisterTriggerStatement when the cacheModel node is processed. When the cacheModel nodes are in a seperate file, its not possible to register a trigger statement becuase the xml files that contain those statements haven't been processed yet. Delaying the registration of cacheModel to just before the cacheModel is attached to the mapped statement makes it possible to declare the cacheModel nodes without requiring the statements exist yet. 
> One of the benefits to being able to keep a seperate file of cacheModel nodes is that you could mark normal sqlMap file as embedded resources while keeping the CacheModel.xml file as a resource on the file system. The CacheModels.xml file can be tweaked without having to recompile the application. 
> To accomplish this, 4 changes need to occur:
> 1)
> Change the SqlMap.xsd file to not require a <statements> node. This allows a <sqlMap> node to contain just a <cacheModels> and/or just a <resultMaps> node.
> 2)
> Add a property in ConfigurationScope.cs to keep track of what statements belong to a cacheModel:
>  public HybridDictionary CacheModelFlushOnExecuteStatements
>  {
>  get { return _cacheModelFlushOnExecuteStatements; }
>  set { _cacheModelFlushOnExecuteStatements = value; }
>  }
> I wonder if there is a cleaner way of doing this ???
> 3)
> Replace this code in DomSqlMapBuilder.cs:
>  IMappedStatement mappedStatement = _configScope.SqlMapper.GetMappedStatement(statementName);
>  cacheModel.RegisterTriggerStatement(mappedStatement);
> with:
>  IList statementNames = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementNames == null)
>  {
>   statementNames = new ArrayList();
>  }
>  statementNames.Add(statementName);
>  _configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id] = statementNames;
> 4)
> Change this line in DomSqlMapBuilder.cs:
>  mappedStatement.Statement.CacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
> to:
>  CacheModel cacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
>  IList statementsToRegister = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementsToRegister != null)
>  {
>   if (statementsToRegister.Contains(mappedStatement.Name))
>   {
>   cacheModel.RegisterTriggerStatement(mappedStatement);
>   }
>   else
>   {
>   // TODO: alert user
>   }
>  }
>  mappedStatement.Statement.CacheModel = cacheModel;
> Do other people think this would be useful? It would certinally make files that contain <statement> nodes a lot cleaner and eliminate to duplication of <cacheModels> and <resultMaps> node across files.
> - Ron

-- 
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
   http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
   http://www.atlassian.com/software/jira


[jira] Updated: (IBATISNET-100) Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized

Posted by "Ron Grabowski (JIRA)" <ib...@incubator.apache.org>.
     [ http://issues.apache.org/jira/browse/IBATISNET-100?page=all ]

Ron Grabowski updated IBATISNET-100:
------------------------------------

    Attachment: DomSqlMapBuilder.patch

Code in comments was incorrect. This patch causes DomSqlMapBuilder.cs to delay registering cacheModels until all sqlMaps have been processed.

> Delay calling cacheModel.RegisterTriggerStatement until all statements have been initialized
> --------------------------------------------------------------------------------------------
>
>          Key: IBATISNET-100
>          URL: http://issues.apache.org/jira/browse/IBATISNET-100
>      Project: iBatis for .NET
>         Type: Improvement
>   Components: DataMapper
>     Reporter: Ron Grabowski
>     Priority: Minor
>  Attachments: DomSqlMapBuilder.patch
>
> I've extracted all of my cacheModel and resultMap nodes to a seperate xml files:
>  /SqlMaps/CacheModels.xml
>  /SqlMaps/ResultMaps.xml
>  /SqlMaps/OleDb/...
>  /SqlMaps/MySQL/...
>  /SqlMaps/SqlServer/...
> to avoid duplicating nodes in database specific files. The database specific files are a lot cleaner becuase they only contain <statement> nodes.
> The current implementation of ConfigureSqlMap() in DomSqlMapBuilder.cs calls RegisterTriggerStatement when the cacheModel node is processed. When the cacheModel nodes are in a seperate file, its not possible to register a trigger statement becuase the xml files that contain those statements haven't been processed yet. Delaying the registration of cacheModel to just before the cacheModel is attached to the mapped statement makes it possible to declare the cacheModel nodes without requiring the statements exist yet. 
> One of the benefits to being able to keep a seperate file of cacheModel nodes is that you could mark normal sqlMap file as embedded resources while keeping the CacheModel.xml file as a resource on the file system. The CacheModels.xml file can be tweaked without having to recompile the application. 
> To accomplish this, 4 changes need to occur:
> 1)
> Change the SqlMap.xsd file to not require a <statements> node. This allows a <sqlMap> node to contain just a <cacheModels> and/or just a <resultMaps> node.
> 2)
> Add a property in ConfigurationScope.cs to keep track of what statements belong to a cacheModel:
>  public HybridDictionary CacheModelFlushOnExecuteStatements
>  {
>  get { return _cacheModelFlushOnExecuteStatements; }
>  set { _cacheModelFlushOnExecuteStatements = value; }
>  }
> I wonder if there is a cleaner way of doing this ???
> 3)
> Replace this code in DomSqlMapBuilder.cs:
>  IMappedStatement mappedStatement = _configScope.SqlMapper.GetMappedStatement(statementName);
>  cacheModel.RegisterTriggerStatement(mappedStatement);
> with:
>  IList statementNames = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementNames == null)
>  {
>   statementNames = new ArrayList();
>  }
>  statementNames.Add(statementName);
>  _configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id] = statementNames;
> 4)
> Change this line in DomSqlMapBuilder.cs:
>  mappedStatement.Statement.CacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
> to:
>  CacheModel cacheModel = _configScope.SqlMapper.GetCache(mappedStatement.Statement.CacheModelName);
>  IList statementsToRegister = (IList)_configScope.CacheModelFlushOnExecuteStatements[cacheModel.Id];
>  if (statementsToRegister != null)
>  {
>   if (statementsToRegister.Contains(mappedStatement.Name))
>   {
>   cacheModel.RegisterTriggerStatement(mappedStatement);
>   }
>   else
>   {
>   // TODO: alert user
>   }
>  }
>  mappedStatement.Statement.CacheModel = cacheModel;
> Do other people think this would be useful? It would certinally make files that contain <statement> nodes a lot cleaner and eliminate to duplication of <cacheModels> and <resultMaps> node across files.
> - Ron

-- 
This message is automatically generated by JIRA.
-
If you think it was sent incorrectly contact one of the administrators:
   http://issues.apache.org/jira/secure/Administrators.jspa
-
For more information on JIRA, see:
   http://www.atlassian.com/software/jira