public virtual void SetTable(SqlTable table, MemberInfo member, IEnumerable<Expression> arguments, IEnumerable<ISqlExpression> sqlArgs)
		{
			table.SqlTableType   = SqlTableType.Function;
			table.Name           = Name ?? member.Name;
			table.PhysicalName   = Name ?? member.Name;
			table.TableArguments = ConvertArgs(member, sqlArgs.ToArray());
		}

		public override ISqlExpression GetIdentityExpression(SqlTable table)
		{
			if (!table.SequenceAttributes.IsNullOrEmpty())
				return new SqlExpression("GEN_ID(" + table.SequenceAttributes[0].SequenceName + ", 1)", Precedence.Primary);

			return base.GetIdentityExpression(table);
		}

		public override ISqlExpression GetIdentityExpression(SqlTable table, SqlField identityField, bool forReturning)
		{
			if (table.SequenceAttributes != null)
				return new SqlExpression("GEN_ID(" + table.SequenceAttributes[0].SequenceName + ", 1)", Precedence.Primary);

			return base.GetIdentityExpression(table, identityField, forReturning);
		}

        public static SqlTable getTableFromRawSql(string rawSql)
        {
            SqlTable sqlTable = new SqlTable();
            using (SqlConnection connection = new SqlConnection(System.Configuration.ConfigurationManager.ConnectionStrings["BROWSitContext"].ConnectionString))
            {
                using (SqlDataAdapter adapter = new SqlDataAdapter(rawSql, connection))
                {
                    try
                    {
                        adapter.Fill(sqlTable.contents);
                    }
                    catch (SqlException e)
                    {
                        //sqlTable.errors = e.Errors;
                        foreach (SqlError se in e.Errors)
                        {
                            sqlTable.errorStrings.Add("Message: " + se.Message
                                + " | Number: " + se.Number
                                + " | Line: " + se.LineNumber
                                + " | Source: " + se.Source
                                + " | Procedure: " + se.Procedure);
                        }
                    }
                }
            }

            return sqlTable;
        }

        public void Ctor_WithTableName_SetsTableNameProperty()
        {
            var table = new SqlTable("[dbo].[Users]");

            Assert.NotNull(table.TableName);
            Assert.Equal("dbo", table.TableName.Segments[0]);
            Assert.Equal("Users", table.TableName.Segments[1]);
        }

        public void ExpressionType_ReturnsJoin()
        {
            var table = new SqlTable("dbo.Users", "u");
            var predicate = SqlExpression.Equal("u.Id", 5);
            var expression = new SqlJoin(SqlJoinType.Left, table);

            Assert.Equal(SqlExpressionType.Join, expression.ExpressionType);
        }

			public override void SetTable(MappingSchema mappingSchema, SqlTable table, MemberInfo member, IEnumerable<Expression> arguments, IEnumerable<ISqlExpression> sqlArgs)
			{
				table.SqlTableType   = SqlTableType.Expression;
				table.Name           = Expression ?? member.Name;
				table.TableArguments = ConvertArgs(member, sqlArgs.ToArray());

				if (Schema   != null) table.Owner    = Schema;
				if (Database != null) table.Database = Database;
			}

        public void ImplicitConversion_WithAlias_ReturnsColumn()
        {
            var table = new SqlTable("[dbo].[Users]", "u");
            var column = table + "Id";

            Assert.NotNull(column);
            Assert.Equal(2, column.ColumnName.Segments.Length);
            Assert.Equal("u", column.ColumnName.Segments.First());
            Assert.Equal("Id", column.ColumnName.Segments.Last());
        }

        public void Test()
        {
            var schema = new MappingSchema();
            schema.SetDataType(typeof (decimal), new SqlDataType(DataType.Decimal, 19, 4));

            var table = new SqlTable<Foo>(schema);

            Assert.That(table.Fields.Single().Value.Precision, Is.EqualTo(19));
            Assert.That(table.Fields.Single().Value.Scale, Is.EqualTo(4));
        }

        public override ISqlExpression GetIdentityExpression(SqlTable table)
        {
            if (!table.SequenceAttributes.IsNullOrEmpty())
            {
                var attr = GetSequenceNameAttribute(table, false);

                if (attr != null)
                    return new SqlExpression(attr.SequenceName + ".nextval", Precedence.Primary);
            }

            return base.GetIdentityExpression(table);
        }

        public override void SetTable(SqlTable table, MemberInfo member, IEnumerable<Expression> expArgs, IEnumerable<ISqlExpression> sqlArgs)
        {
            var aargs  = sqlArgs.ToArray();
            var arr    = ConvertArgs(member, aargs).ToList();
            var method = (MethodInfo)member;

            {
                var ttype  = method.GetGenericArguments()[0];
                var tbl    = new SqlTable(ttype);

                var database     = Convert(tbl.Database);
                var owner        = Convert(tbl.Owner);
                var physicalName = Convert(tbl.PhysicalName);

                var name = "";

                if (database != null)
                    name = database + "." + (owner == null ? "." : owner + ".");
                else if (owner != null)
                    name = owner + ".";

                name += physicalName;

                arr.Add(new SqlExpression(name, Precedence.Primary));
            }

            {
                var field = ((ConstantExpression)expArgs.First()).Value;

                if (field is string)
                {
                    arr[0] = new SqlExpression(field.ToString(), Precedence.Primary);
                }
                else if (field is LambdaExpression)
                {
                    var body = ((LambdaExpression)field).Body;

                    if (body is MemberExpression)
                    {
                        var name = ((MemberExpression)body).Member.Name;

                        if (name.Length > 0 && name[0] != '[')
                            name = "[" + name + "]";

                        arr[0] = new SqlExpression(name, Precedence.Primary);
                    }
                }
            }

            table.SqlTableType   = SqlTableType.Expression;
            table.Name           = "FREETEXTTABLE({6}, {2}, {3}) {1}";
            table.TableArguments = arr.ToArray();
        }

		public override ISqlExpression GetIdentityExpression(SqlTable table, SqlField identityField, bool forReturning)
		{
			if (table.SequenceAttributes != null)
			{
				var attr = GetSequenceNameAttribute(table, false);

				if (attr != null)
					return new SqlExpression(attr.SequenceName + ".nextval", Precedence.Primary);
			}

			return base.GetIdentityExpression(table, identityField, forReturning);
		}

        public void Union_WithRealLifeQuery_ReturnsQuery()
        {
            SqlTable suppliers = new SqlTable("Supplier", "s");
            SqlTable customers = new SqlTable("Customer", "c");
            var actual = Sql
                .Union(
                    Sql.Select(suppliers + "City").From(suppliers),
                    Sql.Select(customers + "City").From(customers))
                .ToSql();

            const string expected = "(SELECT [s].[City] FROM [Supplier] [s]) UNION (SELECT [c].[City] FROM [Customer] [c])";
            Assert.Equal(expected, actual);
        }

        public void Ctor_WithTableAndPredicate_SetsPropertyValues()
        {
            var table = new SqlTable("dbo.Users", "u");
            var predicate = SqlExpression.Equal("u.Id", 5);
            var expression = new SqlJoin(SqlJoinType.Left, table, predicate);

            Assert.NotNull(expression.Table);
            Assert.Same(table, expression.Table);
            Assert.NotNull(expression.On);
            Assert.NotNull(expression.On.Predicate);
            Assert.Same(predicate, expression.On.Predicate);
            Assert.Equal(SqlJoinType.Left, expression.Type);
        }

        public void Select_WithGroupByWithRealLifeQuery_ReturnsQuery()
        {
            SqlTable profiles = new SqlTable("Profile", "p");
            var actual = Sql
                .Select(profiles + "Age", SqlAggregate.Count(profiles + "Id", "Count"))
                .From(profiles)
                .GroupBy(profiles + "Age")
                .Having(SqlExpression.GreaterThanOrEqual(profiles + "Age", 18))
                .ToSql();

            const string expected = "SELECT [p].[Age], COUNT([p].[Id]) AS [Count] FROM [Profile] [p] GROUP BY ([p].[Age]) HAVING [p].[Age] >= 18";
            Assert.Equal(expected, actual);
        }

			protected override SqlQuery ProcessQuery(SqlQuery sqlQuery)
			{
				if (sqlQuery.QueryType == QueryType.Insert && sqlQuery.Set.Into.Name == "Parent")
				{
					var expr =
						new QueryVisitor().Find(sqlQuery.Set, e =>
						{
							if (e.ElementType == QueryElementType.SetExpression)
							{
								var se = (SqlQuery.SetExpression)e;
								return ((SqlField)se.Column).Name == "ParentID";
							}

							return false;
						}) as SqlQuery.SetExpression;

					if (expr != null)
					{
						var value = ConvertTo<int>.From(((IValueContainer)expr.Expression).Value);

						if (value == 555)
						{
							var tableName = "Parent1";
							var dic       = new Dictionary<IQueryElement,IQueryElement>();

							sqlQuery = new QueryVisitor().Convert(sqlQuery, e =>
							{
								if (e.ElementType == QueryElementType.SqlTable)
								{
									var oldTable = (SqlTable)e;

									if (oldTable.Name == "Parent")
									{
										var newTable = new SqlTable(oldTable) { Name = tableName, PhysicalName = tableName };

										foreach (var field in oldTable.Fields.Values)
											dic.Add(field, newTable.Fields[field.Name]);

										return newTable;
									}
								}

								IQueryElement ex;
								return dic.TryGetValue(e, out ex) ? ex : null;
							});
						}
					}
				}

				return sqlQuery;
			}

        public void Select_WithRealLifeQuery_ReturnsQuery()
        {
            SqlTable users = new SqlTable("User", "u");
            SqlTable profiles = new SqlTable("Profile", "p");
            var actual = Sql
                .Select(users + "Id", users + "Name", users + "Email", profiles + "Avatar", profiles + "Birthday")
                .From(users)
                .LeftJoin(profiles).On(SqlExpression.Equal(users + "Id", profiles + "UserId"))
                .Where(SqlExpression.Equal(profiles + "Age", 18))
                .OrderBy(users + "Name")
                .ToSql();

            const string expected = "SELECT [u].[Id], [u].[Name], [u].[Email], [p].[Avatar], [p].[Birthday] FROM [User] [u] LEFT JOIN [Profile] [p] ON [u].[Id] = [p].[UserId] WHERE [p].[Age] = 18 ORDER BY [u].[Name]";
            Assert.Equal(expected, actual);
        }

 public void CreateTable(SqlTable table)
 {
     var columns = GetColumns(table);
     if (columns.Count > 0)
     {
         if (!CompareColumns(table, columns))
         {
             var from = new SqlTable(table.Name, columns);
             database.Query(AlterTableQuery(from, table));
         }
     }
     else
     {
         database.Query(CreateTableQuery(table));
     }
 }

        public void ToSql_WithSelectWithInnerJoinWithOrderByClauseWithWhereClause_WritesCorrectSql()
        {
            var foo = new SqlTable("foo", "f");
            var bar = new SqlTable("bar", "b");

            var sql = Sql
                .Select(foo + "Id", foo + "Name", bar + "Email")
                .From(foo)
                .InnerJoin(bar, SqlExpression.Equal(foo + "Id", bar + "FooId"))
                .Where(SqlExpression.Equal(foo + "Id", 5))
                .OrderBy("Id", SqlSortOrder.Descending)
                .OrderBy("Name")
                .ToSql();

            Assert.AreEqual("SELECT [f].[Id], [f].[Name], [b].[Email] FROM [foo] [f] INNER JOIN [bar] [b] ON ([f].[Id] = [b].[FooId]) WHERE ([f].[Id] = 5) ORDER BY [Id] DESC, [Name] ASC", sql);
        }

 /// <summary>
 /// Alter a table from source to destination
 /// </summary>
 /// <param name="from">Must have name and column names. Column types are not required</param>
 /// <param name="to">Must have column names and column types.</param>
 /// <returns></returns>
 public string AlterTableQuery(SqlTable from, SqlTable to)
 {
     var rstr = rand.NextString(20);
     var alter = "ALTER TABLE '{0}' RENAME TO '{1}_{0}'".SFormat(from.Name, rstr);
     var create = CreateTableQuery(to);
     //combine all columns in the 'from' variable excluding ones that aren't in the 'to' variable.
     //exclude the ones that aren't in 'to' variable because if the column is deleted, why try to import the data?
     var insert = "INSERT INTO '{0}' ({1}) SELECT {1} FROM {2}_{0}".SFormat(from.Name, string.Join(", ", from.Columns.Where(c => to.Columns.Any(c2 => c2.Name == c.Name)).Select(c => c.Name).ToArray()), rstr);
     var drop = "DROP TABLE '{0}_{1}'".SFormat(rstr, from.Name);
     return "{0}; {1}; {2}; {3};".SFormat(alter, create, insert, drop);
     /*
         ALTER TABLE "main"."Bans" RENAME TO "oXHFcGcd04oXHFcGcd04_Bans"
         CREATE TABLE "main"."Bans" ("IP" TEXT PRIMARY KEY ,"Name" TEXT)
         INSERT INTO "main"."Bans" SELECT "IP","Name" FROM "main"."oXHFcGcd04oXHFcGcd04_Bans"
         DROP TABLE "main"."oXHFcGcd04oXHFcGcd04_Bans"
      * 
      */
 }