public static FluentConfiguration ExposeDbCommand(this FluentConfiguration fluentConfiguration, Action <IDbCommand, global::NHibernate.Cfg.Configuration> action) { fluentConfiguration.ExposeConfiguration(cfg => { DbConnection connection = null; IConnectionProvider provider = null; IDbCommand command = null; try { provider = GetConnectionProvider(cfg); connection = provider.GetConnection(); command = connection.CreateCommand(); command.CommandType = CommandType.Text; action(command, cfg); } finally { if (command != null) { command.Dispose(); } if (connection != null) { provider.CloseConnection(connection); provider.Dispose(); } } }); return(fluentConfiguration); }
/// <summary> /// Execute the specified stored procedure with the given parameters and then converts /// the results using the supplied delegate. /// </summary> /// <typeparam name="T2">The collection type to return.</typeparam> /// <param name="converter">The delegate which converts the raw results.</param> /// <param name="sp_name">The name of the stored procedure.</param> /// <param name="parameters">Parameters for the stored procedure.</param> /// <returns></returns> public ICollection <T2> ExecuteStoredProcedure <T2>(Converter <IDataReader, T2> converter, string sp_name, params Parameter[] parameters) { IConnectionProvider connectionProvider = ((ISessionFactoryImplementor)SessionFactory).ConnectionProvider; IDbConnection connection = connectionProvider.GetConnection(); try { using (IDbCommand command = connection.CreateCommand()) { command.CommandText = sp_name; command.CommandType = CommandType.StoredProcedure; RepositoryHelper <T> .CreateDbDataParameters(command, parameters); IDataReader reader = command.ExecuteReader(); ICollection <T2> results = new List <T2>(); while (reader.Read()) { results.Add(converter(reader)); } reader.Close(); return(results); } } finally { connectionProvider.CloseConnection(connection); } }
public int ExecuteStatement(string sql) { using (IConnectionProvider prov = ConnectionProviderFactory.NewConnectionProvider(cfg.Properties)) { IDbConnection conn = prov.GetConnection(); try { using (IDbTransaction tran = conn.BeginTransaction()) using (IDbCommand comm = conn.CreateCommand()) { comm.CommandText = sql; comm.Transaction = tran; comm.CommandType = CommandType.Text; int result = comm.ExecuteNonQuery(); tran.Commit(); return(result); } } finally { prov.CloseConnection(conn); } } }
public void Release() { if (connection != null) { provider.CloseConnection(connection); } }
public int ExecuteStatement(string sql) { if (cfg == null) { cfg = TestConfigurationHelper.GetDefaultConfiguration(); } using (IConnectionProvider prov = ConnectionProviderFactory.NewConnectionProvider(cfg.Properties)) { var conn = prov.GetConnection(); try { using (var tran = conn.BeginTransaction()) using (var comm = conn.CreateCommand()) { comm.CommandText = sql; comm.Transaction = tran; comm.CommandType = CommandType.Text; int result = comm.ExecuteNonQuery(); tran.Commit(); return(result); } } finally { prov.CloseConnection(conn); } } }
private void InitConnectionAndExecute(Action <string> scriptAction, bool execute, bool justDrop, DbConnection connection, TextWriter exportOutput) { Initialize(); TextWriter fileOutput = exportOutput; IConnectionProvider connectionProvider = null; try { if (fileOutput == null && outputFile != null) { fileOutput = new StreamWriter(outputFile); } if (execute && connection == null) { if (_requireTenantConnection) { throw new ArgumentException("When Database multi-tenancy is enabled you need to provide explicit connection. Please use overload with connection parameter."); } var props = new Dictionary <string, string>(); foreach (var de in dialect.DefaultProperties) { props[de.Key] = de.Value; } if (configProperties != null) { foreach (var de in configProperties) { props[de.Key] = de.Value; } } connectionProvider = ConnectionProviderFactory.NewConnectionProvider(props); connection = connectionProvider.GetConnection(); } Execute(scriptAction, execute, justDrop, connection, fileOutput); } catch (HibernateException) { // So that we don't wrap HibernateExceptions in HibernateExceptions throw; } catch (Exception e) { log.Error(e, e.Message); throw new HibernateException(e.Message, e); } finally { if (connectionProvider != null) { connectionProvider.CloseConnection(connection); connectionProvider.Dispose(); } } }
public void Release() { if (connection != null) { connectionProvider.CloseConnection(connection); } connection = null; }
public async Task ExecuteAsync(Action <string> scriptAction, bool execute, bool justDrop, TextWriter exportOutput, CancellationToken cancellationToken = default(CancellationToken)) { cancellationToken.ThrowIfCancellationRequested(); await(InitializeAsync(cancellationToken)).ConfigureAwait(false); DbConnection connection = null; TextWriter fileOutput = exportOutput; IConnectionProvider connectionProvider = null; try { if (fileOutput == null && outputFile != null) { fileOutput = new StreamWriter(outputFile); } if (execute) { var props = new Dictionary <string, string>(); foreach (var de in dialect.DefaultProperties) { props[de.Key] = de.Value; } if (configProperties != null) { foreach (var de in configProperties) { props[de.Key] = de.Value; } } connectionProvider = ConnectionProviderFactory.NewConnectionProvider(props); connection = await(connectionProvider.GetConnectionAsync(cancellationToken)).ConfigureAwait(false); } await(ExecuteAsync(scriptAction, execute, justDrop, connection, fileOutput, cancellationToken)).ConfigureAwait(false); } catch (OperationCanceledException) { throw; } catch (HibernateException) { // So that we don't wrap HibernateExceptions in HibernateExceptions throw; } catch (Exception e) { log.Error(e, e.Message); throw new HibernateException(e.Message, e); } finally { if (connection != null) { connectionProvider.CloseConnection(connection); connectionProvider.Dispose(); } } }
public void Execute(Action <string> scriptAction, bool export, bool justDrop) { Initialize(); IDbConnection connection = null; StreamWriter fileOutput = null; IConnectionProvider connectionProvider = null; var props = new Dictionary <string, string>(); foreach (var de in dialect.DefaultProperties) { props[de.Key] = de.Value; } if (configProperties != null) { foreach (var de in configProperties) { props[de.Key] = de.Value; } } try { if (outputFile != null) { fileOutput = new StreamWriter(outputFile); } if (export) { connectionProvider = ConnectionProviderFactory.NewConnectionProvider(props); connection = connectionProvider.GetConnection(); } Execute(scriptAction, export, justDrop, connection, fileOutput); } catch (HibernateException) { // So that we don't wrap HibernateExceptions in HibernateExceptions throw; } catch (Exception e) { log.Error(e.Message, e); throw new HibernateException(e.Message, e); } finally { if (connection != null) { connectionProvider.CloseConnection(connection); connectionProvider.Dispose(); } } }
public void BulkSave(IConnectionProvider conn, IEntityCollection entitiesToSave, IEntityDaoFactory daoFactory) { IEntityCollection newEntities, changedEntities, removedEntities; SplitCollectionForInsertUpdateAndDeleteOperations(entitiesToSave, out newEntities, out changedEntities, out removedEntities); bool connIsLocal = !conn.IsOpen; if (connIsLocal) conn.OpenConnection(); try { BulkInsert(conn, newEntities, daoFactory); BulkUpdate(conn, changedEntities, daoFactory); BulkDelete(conn, removedEntities, daoFactory); } finally { if (connIsLocal) conn.CloseConnection(); } }
public object ExecuteStoredProcedure(string sp_name, params Parameter[] parameters) { IConnectionProvider connectionProvider = ((ISessionFactoryImplementor)SessionFactory).ConnectionProvider; IDbConnection connection = connectionProvider.GetConnection(); try { using (IDbCommand command = connection.CreateCommand()) { command.CommandText = sp_name; command.CommandType = CommandType.StoredProcedure; RepositoryHelper <T> .CreateDbDataParameters(command, parameters); return(command.ExecuteScalar()); } } finally { connectionProvider.CloseConnection(connection); } }
public void AttemptToDeleteImmutableObjectShouldThrow() { using (ISession session = OpenSession()) { Assert.Throws <HibernateException>(() => { using (ITransaction trans = session.BeginTransaction()) { var entity = session.Get <DomainClass>(1); session.Delete(entity); trans.Commit(); // This used to throw... } }); } using (IConnectionProvider prov = ConnectionProviderFactory.NewConnectionProvider(cfg.Properties)) { var conn = prov.GetConnection(); try { using (var comm = conn.CreateCommand()) { comm.CommandText = "SELECT Id FROM DomainClass WHERE Id=1 AND Label='TEST record'"; object result = comm.ExecuteScalar(); Assert.That(result != null, "Immutable object has been deleted!"); } } finally { prov.CloseConnection(conn); } } }
public void AllowDeletionOfImmutableObject() { using (ISession session = OpenSession()) { Assert.DoesNotThrow(() => { using (ITransaction trans = session.BeginTransaction()) { var entity = session.Get <DomainClass>(1); session.Delete(entity); trans.Commit(); } }); } using (IConnectionProvider prov = ConnectionProviderFactory.NewConnectionProvider(cfg.Properties)) { var conn = prov.GetConnection(); try { using (var comm = conn.CreateCommand()) { comm.CommandText = "SELECT Id FROM DomainClass WHERE Id=1 AND Label='TEST record'"; object result = comm.ExecuteScalar(); Assert.That(result == null, "Immutable object has not been deleted!"); } } finally { prov.CloseConnection(conn); } } }
public async Task AllowDeletionOfImmutableObjectAsync() { using (ISession session = OpenSession()) { Assert.DoesNotThrowAsync(async() => { using (ITransaction trans = session.BeginTransaction()) { var entity = await(session.GetAsync <DomainClass>(1)); await(session.DeleteAsync(entity)); await(trans.CommitAsync()); } }); } using (IConnectionProvider prov = ConnectionProviderFactory.NewConnectionProvider(cfg.Properties)) { var conn = await(prov.GetConnectionAsync(CancellationToken.None)); try { using (var comm = conn.CreateCommand()) { comm.CommandText = "SELECT Id FROM DomainClass WHERE Id=1 AND Label='TEST record'"; object result = await(comm.ExecuteScalarAsync()); Assert.That(result == null, "Immutable object has not been deleted!"); } } finally { prov.CloseConnection(conn); } } }
private static int CountWithLeafFilter(IConnectionProvider conn, IEntity rootEntity, DbRelation recursiveRelation, SearchCondition leafFilter, int beginAtLevel, int endAtLevel) { // Stop condition: final level reached (tree depth is measured). int totalCount = 0; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.OpenConnection(); endAtLevel = GetEndLevel(conn, rootEntity, recursiveRelation, endAtLevel); bool reachedEndLevel = false; int level = beginAtLevel; do { SelectStatement countAtLevel = CreateSelectFromLevelQuery(rootEntity, recursiveRelation, leafFilter, level, LevelQuerySelectList.Count); DataTable results = countAtLevel.Execute(conn); totalCount += Convert.ToInt32(results.Rows[0][0], CultureInfo.InvariantCulture); reachedEndLevel = (level >= endAtLevel); level++; } while (!reachedEndLevel); } finally { if (isLocalConn) conn.CloseConnection(); } return totalCount; }
private static int UpdateAll(IConnectionProvider conn, IEntity rootEntity, DbRelation recursiveRelation, UpdateList setExpressions, int beginAtLevel, int endAtLevel) { // Stop condition: rowsAffected == 0 int totalRowsAffected = 0; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.BeginTransaction(); // We need to perform COUNT at least once to determine whether rowsAffacted returned by UPDATE can be trusted. RowsAffectedCredibility trustRowsAffected = RowsAffectedCredibility.NotDetermined; bool reachedEndLevel = false; int level = beginAtLevel; do { // Dependening on DBMS configuration, update statements may automatically return the number of rows affected. int rowsAffectedReturnedByEngine = UpdateAtLevel(conn, rootEntity, recursiveRelation, setExpressions, level); // We need to perform manual counting for as long as rows affected cannot be trusted. int? manualNodeCount = CountNodesAtLevelIfRowsAffectedCannotBeTrusted(conn, rootEntity, trustRowsAffected, recursiveRelation, level); // Evaluation which determines whether rows affected may be trusted takes place only once, ie. if not yet determined. bool evaluateRowsAffectedCredibility = (trustRowsAffected == RowsAffectedCredibility.NotDetermined) && (manualNodeCount.HasValue); if (evaluateRowsAffectedCredibility) { bool engineCountMatchesManualCount = (rowsAffectedReturnedByEngine == manualNodeCount.Value); trustRowsAffected = (engineCountMatchesManualCount) ? RowsAffectedCredibility.Trusted : RowsAffectedCredibility.Untrusted; } // Manual node count is null if we have determined that rows affected value returned by engine is credible. int rowsUpdatedInCurrentLevel = manualNodeCount ?? rowsAffectedReturnedByEngine; totalRowsAffected += rowsUpdatedInCurrentLevel; // Inspect stop condition before level variable is increased. reachedEndLevel = IsEndLevelReached(endAtLevel, level, rowsUpdatedInCurrentLevel); // Next level. level++; } while (!reachedEndLevel); if (isLocalConn) conn.CommitTransaction(); } finally { if (isLocalConn) conn.CloseConnection(); } return totalRowsAffected; }
private static int UpdateWithLeafFilter(IConnectionProvider conn, IEntity rootEntity, DbRelation recursiveRelation, UpdateList setExpressions, SearchCondition leafFilter, int beginAtLevel, int endAtLevel) { // Stop condition: final level reached (tree depth is measured). // It's possible that at some intermediate levels no records satisfy the specified criteria. // Nevertheless, the algorithm must proceed to the next level where it might find matching records. // This behavior simulates the behavior of recursive CTEs. int totalRowsAffected = 0; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.BeginTransaction(); endAtLevel = GetEndLevel(conn, rootEntity, recursiveRelation, endAtLevel); bool reachedEndLevel = false; int level = beginAtLevel; do { UpdateStatement updateAtLevel = CreateUpdateLevelStatement(rootEntity, recursiveRelation, setExpressions, leafFilter, level); totalRowsAffected += updateAtLevel.Execute(conn); reachedEndLevel = (level >= endAtLevel); level++; } while (!reachedEndLevel); if (isLocalConn) conn.CommitTransaction(); } finally { if (isLocalConn) conn.CloseConnection(); } return totalRowsAffected; }
private static int DetermineTreeDepthInternal(IConnectionProvider conn, IEntity rootEntity, DbRelation recursiveRelation) { EnsureRecursiveRelation(recursiveRelation); int depth = 0; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.OpenConnection(); bool reachedEndLevel = false; do { SelectStatement countAtLevel = CreateSelectFromLevelQuery(rootEntity, recursiveRelation, null, depth, LevelQuerySelectList.Count); DataTable results = countAtLevel.Execute(conn); int nodeCount = Convert.ToInt32(results.Rows[0][0], CultureInfo.InvariantCulture); if (nodeCount > 0) depth++; else reachedEndLevel = true; } while (!reachedEndLevel); } finally { if (isLocalConn) conn.CloseConnection(); } return depth; }
private static DataTable SelectAll(IConnectionProvider conn, IEntity rootEntity, DbRelation recursiveRelation, int beginAtLevel, int endAtLevel) { // Stop condition: select returns nothing. DataTable mergedData = null; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.OpenConnection(); bool reachedEndLevel = false; int level = beginAtLevel; do { SelectStatement fetchLevel = CreateSelectFromLevelQuery(rootEntity, recursiveRelation, null, level, LevelQuerySelectList.AllColumns); DataTable levelData = fetchLevel.Execute(conn); if (levelData.Rows.Count > 0) AppendData(levelData, ref mergedData); reachedEndLevel = (levelData.Rows.Count == 0) || (level >= endAtLevel); level++; } while (!reachedEndLevel); } finally { if (isLocalConn) conn.CloseConnection(); } return mergedData; }
/// <summary> /// Executes the Export of the Schema. /// </summary> /// <param name="script"><c>true</c> if the ddl should be outputted in the Console.</param> /// <param name="export"><c>true</c> if the ddl should be executed against the Database.</param> /// <param name="justDrop"><c>true</c> if only the ddl to drop the Database objects should be executed.</param> /// <param name="format"><c>true</c> if the ddl should be nicely formatted instead of one statement per line.</param> /// <remarks> /// This method allows for both the drop and create ddl script to be executed. /// </remarks> public void Execute(bool script, bool export, bool justDrop, bool format) { IDbConnection connection = null; StreamWriter fileOutput = null; IConnectionProvider connectionProvider = null; IDbCommand statement = null; IDictionary props = new Hashtable(); foreach (DictionaryEntry de in dialect.DefaultProperties) { props[de.Key] = de.Value; } if (connectionProperties != null) { foreach (DictionaryEntry de in connectionProperties) { props[de.Key] = de.Value; } } try { if (outputFile != null) { fileOutput = new StreamWriter(outputFile); } if (export) { connectionProvider = ConnectionProviderFactory.NewConnectionProvider(props); connection = connectionProvider.GetConnection(); statement = connection.CreateCommand(); } for (int i = 0; i < dropSQL.Length; i++) { try { string formatted; if (format) { formatted = Format(dropSQL[i]); } else { formatted = dropSQL[i]; } if (delimiter != null) { formatted += delimiter; } if (script) { Console.WriteLine(formatted); } if (outputFile != null) { fileOutput.WriteLine(formatted); } if (export) { statement.CommandText = dropSQL[i]; statement.CommandType = CommandType.Text; statement.ExecuteNonQuery(); } } catch (Exception e) { if (!script) { Console.WriteLine(dropSQL[i]); } Console.WriteLine("Unsuccessful: " + e.Message); } } if (!justDrop) { for (int j = 0; j < createSQL.Length; j++) { try { string formatted; if (format) { formatted = Format(createSQL[j]); } else { formatted = createSQL[j]; } if (delimiter != null) { formatted += delimiter; } if (script) { Console.WriteLine(formatted); } if (outputFile != null) { fileOutput.WriteLine(formatted); } if (export) { statement.CommandText = createSQL[j]; statement.CommandType = CommandType.Text; statement.ExecuteNonQuery(); } } catch (Exception e) { if (!script) { Console.WriteLine(createSQL[j]); } Console.WriteLine("Unsuccessful: " + e.Message); // Fail on create script errors throw; } } } } catch (HibernateException) { // So that we don't wrap HibernateExceptions in HibernateExceptions throw; } catch (Exception e) { Console.Write(e.StackTrace); throw new HibernateException(e.Message, e); } finally { try { if (statement != null) { statement.Dispose(); } if (connection != null) { connectionProvider.CloseConnection(connection); connectionProvider.Dispose(); } } catch (Exception e) { Console.Error.WriteLine("Could not close connection: " + e.Message); } if (fileOutput != null) { try { fileOutput.Close(); } catch (Exception ioe) { Console.Error.WriteLine("Error closing output file " + outputFile + ": " + ioe.Message); } } } }
private static object MaxOfAll(IConnectionProvider conn, IEntity rootEntity, IDbColumn column, DbRelation recursiveRelation, int beginAtLevel, int endAtLevel) { // Stop condition: count returns zero. object maximum = null; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.OpenConnection(); bool reachedEndLevel = false; int level = beginAtLevel; do { object levelMax; int nodeCount; FetchMaxFromColumnAndCountAllNodesAtLevel(conn, rootEntity, recursiveRelation, level, column.ColumnName, out levelMax, out nodeCount); maximum = MaxOfNullableValues(maximum as IComparable, levelMax as IComparable); reachedEndLevel = (nodeCount == 0) || (level >= endAtLevel); level++; } while (!reachedEndLevel); } finally { if (isLocalConn) conn.CloseConnection(); } if (maximum == null) maximum = DBNull.Value; return maximum; }
private static object SumAll(IConnectionProvider conn, IEntity rootEntity, IDbColumn column, DbRelation recursiveRelation, int beginAtLevel, int endAtLevel) { // Stop condition: count returns zero. object totalSum = null; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.OpenConnection(); bool reachedEndLevel = false; int level = beginAtLevel; do { SelectStatement sumAtLevel = CreateSelectFromLevelQuery(rootEntity, recursiveRelation, null, level, LevelQuerySelectList.Default); sumAtLevel.SelectList.Clear(); IDbColumn summedColumn = sumAtLevel.FromTable.Columns.GetByColumnName(column.ColumnName); sumAtLevel.SelectList.Add(AggregateFunctionFactory.Sum(summedColumn, false, "levelSum")); sumAtLevel.SelectList.Add(AggregateFunctionFactory.Count("nodeCount")); DataTable results = sumAtLevel.Execute(conn); object levelSum = results.Rows[0]["levelSum"]; int nodeCount = Convert.ToInt32(results.Rows[0]["nodeCount"], CultureInfo.InvariantCulture); totalSum = SumNullableValues(column, totalSum, levelSum); reachedEndLevel = (nodeCount == 0) || (level >= endAtLevel); level++; } while (!reachedEndLevel); } finally { if (isLocalConn) conn.CloseConnection(); } return totalSum; }
private static int CountAll(IConnectionProvider conn, IEntity rootEntity, DbRelation recursiveRelation, int beginAtLevel, int endAtLevel) { // Stop condition: count returns zero. int totalCount = 0; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.OpenConnection(); bool reachedEndLevel = false; int level = beginAtLevel; do { SelectStatement countAtLevel = CreateSelectFromLevelQuery(rootEntity, recursiveRelation, null, level, LevelQuerySelectList.Count); DataTable results = countAtLevel.Execute(conn); int nodeCount = Convert.ToInt32(results.Rows[0][0], CultureInfo.InvariantCulture); totalCount += nodeCount; reachedEndLevel = (nodeCount == 0) || (level >= endAtLevel); level++; } while (!reachedEndLevel); } finally { if (isLocalConn) conn.CloseConnection(); } return totalCount; }
private static object InsertAndSelectAutoNumber(IConnectionProvider conn, string command, DbParameterCollection parameters, int cmdTimeout = 30) { bool isLocalConn = !conn.IsOpen; if (isLocalConn) conn.OpenConnection(); try { DbUtil.ExecuteNonQuery(conn, command, parameters, CommandType.Text, cmdTimeout); // ROWID is always a 64bit integer. DataTable data = DbUtil.ExecuteQuery(conn, "SELECT last_insert_rowid()", new DbParameterCollection(), CommandType.Text, null, cmdTimeout); int lastId = Convert.ToInt32(data.Rows[0][0], CultureInfo.InvariantCulture); return lastId; } finally { if (isLocalConn) conn.CloseConnection(); } }
private static void CloseConnectionIfLocal(IConnectionProvider conn, bool connIsOpennedLocally) { // Close connection if it was openned in this method. if (connIsOpennedLocally) conn.CloseConnection(); }
public void BulkDelete(IConnectionProvider conn, IEntityCollection removedEntities, IEntityDaoFactory daoFactory) { if (removedEntities.Count == 0) return; bool connIsLocal = !conn.IsOpen; if (connIsLocal) conn.OpenConnection(); try { foreach (IEntity entity in removedEntities) GetDao(conn, entity, daoFactory).DeleteOne(); } finally { if (connIsLocal) conn.CloseConnection(); } }
private static object SumWithLeafFilter(IConnectionProvider conn, IEntity rootEntity, IDbColumn column, DbRelation recursiveRelation, SearchCondition leafFilter, int beginAtLevel, int endAtLevel) { // Stop condition: final level reached (tree depth is measured). object totalSum = null; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.OpenConnection(); endAtLevel = GetEndLevel(conn, rootEntity, recursiveRelation, endAtLevel); bool reachedEndLevel = false; int level = beginAtLevel; do { SelectStatement sumAtLevel = CreateSelectFromLevelQuery(rootEntity, recursiveRelation, leafFilter, level, LevelQuerySelectList.Default); sumAtLevel.SelectList.Clear(); IDbColumn summedColumn = sumAtLevel.FromTable.Columns.GetByColumnName(column.ColumnName); sumAtLevel.SelectList.Add(AggregateFunctionFactory.Sum(summedColumn, false, "levelSum")); DataTable results = sumAtLevel.Execute(conn); object levelSum = results.Rows[0]["levelSum"]; totalSum = SumNullableValues(column, totalSum, levelSum); reachedEndLevel = (level >= endAtLevel); level++; } while (!reachedEndLevel); } finally { if (isLocalConn) conn.CloseConnection(); } return totalSum; }
public void CloseConnection(DbConnection conn) { _connectionProvider.CloseConnection(conn); }
private static object MaxWithLeafFilter(IConnectionProvider conn, IEntity rootEntity, IDbColumn column, DbRelation recursiveRelation, SearchCondition leafFilter, int beginAtLevel, int endAtLevel) { // Stop condition: final level reached (tree depth is measured). object maximum = null; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.OpenConnection(); endAtLevel = GetEndLevel(conn, rootEntity, recursiveRelation, endAtLevel); bool reachedEndLevel = false; int level = beginAtLevel; do { SelectStatement maxAtLevel = CreateSelectFromLevelQuery(rootEntity, recursiveRelation, leafFilter, level, LevelQuerySelectList.Default); maxAtLevel.SelectList.Clear(); IDbColumn comparedColumn = maxAtLevel.FromTable.Columns.GetByColumnName(column.ColumnName); maxAtLevel.SelectList.Add(AggregateFunctionFactory.Max(comparedColumn, "levelMax")); DataTable results = maxAtLevel.Execute(conn); object levelMax = results.Rows[0]["levelMax"]; maximum = MaxOfNullableValues(maximum as IComparable, levelMax as IComparable); reachedEndLevel = (level >= endAtLevel); level++; } while (!reachedEndLevel); } finally { if (isLocalConn) conn.CloseConnection(); } if (maximum == null) maximum = DBNull.Value; return maximum; }
private static DataTable SelectWithLeafFilter(IConnectionProvider conn, IEntity rootEntity, DbRelation recursiveRelation, SearchCondition leafFilter, int beginAtLevel, int endAtLevel) { // Stop condition: final level reached (tree depth is measured). // It's possible that at some intermediate levels no records satisfy the specified criteria. // Nevertheless, the algorithm must proceed to the next level where it might find matching records. // This behavior simulates the behavior of recursive CTEs. DataTable mergedData = null; bool isLocalConn = !conn.IsOpen; try { if (isLocalConn) conn.OpenConnection(); endAtLevel = GetEndLevel(conn, rootEntity, recursiveRelation, endAtLevel); bool reachedEndLevel = false; int level = beginAtLevel; do { SelectStatement fetchLevel = CreateSelectFromLevelQuery(rootEntity, recursiveRelation, leafFilter, level, LevelQuerySelectList.AllColumns); DataTable levelData = fetchLevel.Execute(conn); if (levelData.Rows.Count > 0) AppendData(levelData, ref mergedData); reachedEndLevel = (level >= endAtLevel); level++; } while (!reachedEndLevel); } finally { if (isLocalConn) conn.CloseConnection(); } return mergedData; }
private static object InsertAndSelectAutoNumber(IConnectionProvider conn, string command, DbParameterCollection parameters, int cmdTimeout = 30) { // "SELECT @@IDENTITY" must be executed using the same connection context as INSERT statement. // Otherwise SQL CE returns NULL. bool isLocalConn = !conn.IsOpen; if (isLocalConn) conn.OpenConnection(); try { DbUtil.ExecuteNonQuery(conn, command, parameters, CommandType.Text, cmdTimeout); DataTable data = DbUtil.ExecuteQuery(conn, "SELECT @@IDENTITY", new DbParameterCollection(), CommandType.Text, null, cmdTimeout); int lastId = Convert.ToInt32(data.Rows[0][0], CultureInfo.InvariantCulture); return lastId; } finally { if (isLocalConn) conn.CloseConnection(); } }
public void CloseConnection(DbConnection conn) { _base.CloseConnection(conn); }