public static object InsertInto(this object o, string table, ConnectionProfile connectionProfile = null)
        {
            if (connectionProfile == null) connectionProfile = new ConnectionProfile();

            DynamicRepository dynamicModel = new DynamicRepository(connectionProfile, table, "Id");

            return dynamicModel.Insert(o);
        }

        public DynamicModels Execute(dynamic options,
            DynamicRepository repository,
            string associationName,
            string selectClause,
            IEnumerable<dynamic> models,
            string parentMemberName)
        {
            if (ShouldDiscardCache(options)) Cache = null;

            if (Cache != null) return Cache;

            var many = repository.Query(selectClause).ToList();

            foreach (var item in many)
            {
                var model = models.First(s => s.Id == item.GetMember(parentMemberName));

                item.SetMember(model.GetType().Name, model);
            }

            foreach (var model in models)
            {
                var assocation = model.AssociationNamed(associationName);

                var relatedTo = many.Where(s => s.GetMember(model.GetType().Name).Equals(model)).Select(s => s);

                assocation.EagerLoadMany.Cache = new DynamicModels(relatedTo);

                assocation.AddNewAssociationMethod(assocation.EagerLoadMany.Cache, model);
            }

            return new DynamicModels(many);
        }

        void saving_dynamic_params()
        {
            before = () =>
            {
                seed = new Seed();

                seed.PurgeDb();

                seed.CreateTable("Blogs", new dynamic[]
                {
                    new { Id = "int", Identity = true, PrimaryKey = true },
                    new { Title = "nvarchar(255)" }
                }).ExecuteNonQuery();

                nameValueCollection.Add("Title", "Some Title");
            };

            it["persists saveable values to the database"] = () =>
            {
                var blogs = new DynamicRepository("Blogs");

                var blogId = blogs.Insert(asDynamic);

                var blog = blogs.Single(blogId);

                (blog.Title as string).should_be("Some Title");
            };
        }

 public virtual void AddRepository(DynamicModels collection, DynamicRepository repository)
 {
     collection.SetMember("Repository", repository);
 }

        public BelongsTo(DynamicRepository repository)
            : this(repository, null)
        {

        }

 public HasOneThrough(DynamicRepository repository, DynamicRepository through)
     : this(repository, through, null)
 {
 }

        public HasOne(DynamicRepository repository)
            : this(repository, null)
        {

        }

        public HasMany(DynamicRepository repository, string methodName)
        {
            this.Repository = repository;

            this.MethodName = methodName ?? repository.TableName;
        }

        public HasMany(DynamicRepository repository, string named)
        {
            this.repository = repository;

            this.named = named ?? repository.GetType().Name;
        }

 public BelongsTo(DynamicRepository repository, string named)
 {
     this.Repository = repository;
     Named = named ?? Singular(repository);
 }

 public HasOneThrough(DynamicRepository repository, DynamicRepository through, string named)
 {
     this.Repository = repository;
     this.through = through;
     Named = named ?? Singular(Repository);
 }

        public HasOne(DynamicRepository repository, string named)
        {
            this.Repository = repository;

            Named = named ?? Singular(Repository);
        }

        public static DynamicRepository RepositoryFor(string tableName)
        {
            var repo = new DynamicRepository(tableName);

            AssociationByConventions.ApplyProjection(repo);

            return repo;
        }

        public HasManyThrough(DynamicRepository repository, DynamicRepository through, string methodName)
        {
            this.Repository = repository;

            this.through = through;

            this.throughTable = through.TableName;

            this.MethodName = methodName ?? repository.TableName;
        }

        public HasManyThrough(DynamicRepository repository, DynamicRepository through, string named)
        {
            this.repository = repository;

            this.through = through;

            this.named = named ?? repository.GetType().Name;
        }

 public HasOne(DynamicRepository repository)
 {
     this.repository = repository;
 }

        public HasManyAndBelongsTo(DynamicRepository repository, DynamicRepository reference)
        {
            Repository = repository;

            this.reference = reference;

            var sorted = new[] { repository.TableName, reference.TableName }.OrderBy(s => s);

            throughTable = sorted.First() + sorted.Last();

            MethodName = repository.TableName;
        }

 public HasOneThrough(DynamicRepository repository, DynamicRepository through)
 {
     this.repository = repository;
     this.through = through;
 }

 public BelongsTo(DynamicRepository repository)
 {
     this.repository = repository;
     name = Singular(repository);
 }

 public Uniqueness(string property, DynamicRepository usingRepository)
     : base(property)
 {
     Repository = usingRepository;
 }