public JoinClause(ObjectReference table, JoinType joinType, SimpleExpression joinExpression)
 {
     if (table == null) throw new ArgumentNullException("table");
     _table = table;
     _joinType = joinType;
     _joinExpression = joinExpression;
 }

 internal override IDictionary<string, object> FindOne(string tableName, SimpleExpression criteria)
 {
     try
     {
         return _adapter.FindOne(tableName, criteria);
     }
     catch (NotImplementedException)
     {
         return Find(tableName, criteria).FirstOrDefault();
     }
 }

 public virtual Func<object[], IDictionary<string, object>> CreateFindOneDelegate(Adapter adapter, string tableName, SimpleExpression criteria)
 {
     return adapter.CreateFindOneDelegate(tableName, criteria);
 }

 /// <summary>
 ///  Updates the specified "table" according to specified criteria.
 ///  </summary><param name="tableName">Name of the table.</param><param name="data">The new values.</param><param name="criteria">The expression to use as criteria for the update operation.</param><returns>The number of records affected by the update operation.</returns>
 public override int Update(string tableName, IDictionary<string, object> data, SimpleExpression criteria)
 {
     return _adapter.Update(tableName, data, criteria);
 }

 public int Delete(string tableName, SimpleExpression criteria, IAdapterTransaction transaction)
 {
     return Delete(tableName, criteria);
 }

 public IEnumerable<IDictionary<string, object>> Find(string tableName, SimpleExpression criteria, IAdapterTransaction transaction)
 {
     return Find(tableName, criteria);
 }

 internal override int Delete(string tableName, SimpleExpression criteria)
 {
     return _adapter.Delete(tableName, criteria, AdapterTransaction);
 }

 internal override IEnumerable<IDictionary<string, object>> Find(string tableName, SimpleExpression criteria)
 {
     return _adapter.Find(tableName, criteria, AdapterTransaction);
 }

 public override int Update(string tableName, IDictionary<string, object> data, SimpleExpression criteria)
 {
     int count = 0;
     foreach (var record in Find(tableName, criteria))
     {
         UpdateRecord(data, record);
         ++count;
     }
     return count;
 }

 public JoinClause(ObjectReference table, SimpleExpression joinExpression)
 {
     _table = table;
     _joinExpression = joinExpression;
 }

		public abstract object Min(string tableName, string columnName, SimpleExpression criteria);

 public SimpleQueryJoin(ObjectReference table, SimpleExpression joinExpression)
 {
     _table = table;
     _joinExpression = joinExpression;
 }

 internal abstract IDictionary<string, object> FindOne(string getQualifiedName, SimpleExpression criteriaExpression);

        public virtual IDictionary<string, object> Upsert(string tableName, IDictionary<string, object> dict, SimpleExpression criteriaExpression, bool isResultRequired, IAdapterTransaction transaction)
        {
            var transactionAdapter = this as IAdapterWithTransactions;
            if (transactionAdapter == null) throw new NotSupportedException("Transactions are not supported with current adapter.");
            if (transactionAdapter.Find(tableName, criteriaExpression, transaction).Any())
            {
                transactionAdapter.Update(tableName, dict, criteriaExpression, transaction);
                return isResultRequired ? transactionAdapter.Find(tableName, criteriaExpression, transaction).FirstOrDefault() : null;
            }

            return transactionAdapter.Insert(tableName, dict, transaction, isResultRequired);
        }

 /// <summary>
 /// Finds data from the specified "table".
 /// </summary>
 /// <param name="tableName">Name of the table.</param>
 /// <param name="criteria">The criteria. This may be <c>null</c>, in which case all records should be returned.</param>
 /// <returns>The list of records matching the criteria. If no records are found, return an empty list.</returns>
 public abstract IEnumerable<IDictionary<string, object>> Find(string tableName, SimpleExpression criteria);

 /// <summary>
 /// Updates the specified "table" according to specified criteria.
 /// </summary>
 /// <param name="tableName">Name of the table.</param>
 /// <param name="data">The new values.</param>
 /// <param name="criteria">The expression to use as criteria for the update operation.</param>
 /// <returns>The number of records affected by the update operation.</returns>
 public abstract int Update(string tableName, IDictionary<string, object> data, SimpleExpression criteria);

 public override int Delete(string tableName, SimpleExpression criteria)
 {
     List<IDictionary<string, object>> deletions = Find(tableName, criteria).ToList();
     foreach (var record in deletions)
     {
         GetTable(tableName).Remove(record);
     }
     return deletions.Count;
 }

 internal override IDictionary<string, object> FindOne(string tableName, SimpleExpression criteria)
 {
     return _adapter.FindOne(tableName, criteria);
 }

 public override IEnumerable<IDictionary<string, object>> Find(string tableName, SimpleExpression criteria)
 {
     var whereClauseHandler = new WhereClauseHandler(new WhereClause(criteria));
     return whereClauseHandler.Run(GetTable(tableName));
 }

 internal override int Update(string tableName, IDictionary<string, object> data, SimpleExpression criteria)
 {
     return _adapter.Update(tableName, data, criteria, AdapterTransaction);
 }