diff --git a/Simple.Data.Ado/ProcedureExecutor.cs b/Simple.Data.Ado/ProcedureExecutor.cs
index e82670c7..5546e5d1 100644
--- a/Simple.Data.Ado/ProcedureExecutor.cs
+++ b/Simple.Data.Ado/ProcedureExecutor.cs
@@ -48,7 +48,7 @@ public IEnumerable<ResultSet> Execute(IDictionary<string, object> suppliedParame
             using (var command = cn.CreateCommand(_adapter.AdoOptions))
             {
                 command.Transaction = transaction;
-                command.CommandText = procedure.QualifiedName;
+                command.CommandText = string.IsNullOrEmpty(procedure.AliasedProcedure) ? procedure.QualifiedName : procedure.AliasedProcedure;
                 command.CommandType = CommandType.StoredProcedure;
                 SetParameters(procedure, command, suppliedParameters);
                 try
diff --git a/Simple.Data.Ado/Schema/DatabaseSchema.cs b/Simple.Data.Ado/Schema/DatabaseSchema.cs
index 2a1e6265..3026cc19 100644
--- a/Simple.Data.Ado/Schema/DatabaseSchema.cs
+++ b/Simple.Data.Ado/Schema/DatabaseSchema.cs
@@ -98,7 +98,7 @@ private string DefaultSchema
         private TableCollection CreateTableCollection()
         {
             return new TableCollection(_schemaProvider.GetTables()
-                .Select(table => new Table(table.ActualName, table.Schema, table.Type, this)));
+                .Select(table => new Table(table.ActualName, table.Schema, table.Type, this, table.AliasedTable)));
         }
 
         private ProcedureCollection CreateProcedureCollection()
@@ -107,7 +107,7 @@ private ProcedureCollection CreateProcedureCollection()
                                                      .Select(
                                                          proc =>
                                                          new Procedure(proc.Name, proc.SpecificName, proc.Schema,
-                                                                             this)), _schemaProvider.GetDefaultSchema());
+                                                                             this, proc.AliasedProcedure)), _schemaProvider.GetDefaultSchema());
         }
 
         public string QuoteObjectName(string unquotedName)
diff --git a/Simple.Data.Ado/Schema/Procedure.cs b/Simple.Data.Ado/Schema/Procedure.cs
index 68b5f68b..b9738730 100644
--- a/Simple.Data.Ado/Schema/Procedure.cs
+++ b/Simple.Data.Ado/Schema/Procedure.cs
@@ -13,23 +13,26 @@ public class Procedure
         private readonly string _name;
         private readonly string _specificName;
         private readonly string _schema;
+        private readonly string _aliasedProc;
         private readonly Lazy<ParameterCollection> _lazyParameters;
 
-        public Procedure(string name, string specificName, string schema)
+        public Procedure(string name, string specificName, string schema, string aliasedProc = "")
         {
             _name = name;
             _specificName = specificName;
             _schema = schema.NullIfWhitespace();
+            _aliasedProc = aliasedProc;
             _lazyParameters = new Lazy<ParameterCollection>(() => new ParameterCollection(GetParameters()));
          }
 
-        internal Procedure(string name, string specificName, string schema, DatabaseSchema databaseSchema)
+        internal Procedure(string name, string specificName, string schema, DatabaseSchema databaseSchema, string aliasedProc = "")
         {
             _name = name;
             _specificName = specificName;
             _schema = schema.NullIfWhitespace();
             _lazyParameters = new Lazy<ParameterCollection>(() => new ParameterCollection(GetParameters()));
             _databaseSchema = databaseSchema;
+            _aliasedProc = aliasedProc;
         }
 
         private IEnumerable<Parameter> GetParameters()
@@ -52,6 +55,11 @@ public string Name
             get { return _name; }
         }
 
+        public string AliasedProcedure
+        {
+            get { return _aliasedProc; }
+        }
+
         public ParameterCollection Parameters
         {
             get { return _lazyParameters.Value; }
diff --git a/Simple.Data.Ado/Schema/Table.cs b/Simple.Data.Ado/Schema/Table.cs
index a659dac3..74eb54e4 100644
--- a/Simple.Data.Ado/Schema/Table.cs
+++ b/Simple.Data.Ado/Schema/Table.cs
@@ -11,19 +11,21 @@ public class Table : IEquatable<Table>
         private readonly string _actualName;
         private readonly string _schema;
         private readonly TableType _type;
+        private readonly string _aliasedTable;
         private readonly DatabaseSchema _databaseSchema;
         private readonly Lazy<ColumnCollection> _lazyColumns;
         private readonly Lazy<Key> _lazyPrimaryKey;
         private readonly Lazy<ForeignKeyCollection> _lazyForeignKeys;
 
-        public Table(string name, string schema, TableType type)
+        public Table(string name, string schema, TableType type, string aliasedTable = "")
         {
             _actualName = name;
             _schema = string.IsNullOrWhiteSpace(schema) ? null : schema;
             _type = type;
+            _aliasedTable = aliasedTable;
         }
 
-        internal Table(string name, string schema, TableType type, DatabaseSchema databaseSchema)
+        internal Table(string name, string schema, TableType type, DatabaseSchema databaseSchema, string aliasedTable = "")
         {
             _actualName = name;
             _databaseSchema = databaseSchema;
@@ -32,6 +34,7 @@ internal Table(string name, string schema, TableType type, DatabaseSchema databa
             _lazyColumns = new Lazy<ColumnCollection>(GetColumns);
             _lazyPrimaryKey = new Lazy<Key>(GetPrimaryKey);
             _lazyForeignKeys = new Lazy<ForeignKeyCollection>(GetForeignKeys);
+            _aliasedTable = aliasedTable;
         }
 
         public TableType Type
@@ -74,6 +77,11 @@ public string QualifiedName
             }
         }
 
+        public string AliasedTable
+        {
+            get { return _aliasedTable; }
+        }
+
         public IEnumerable<Column> Columns
         {
             get { return _lazyColumns.Value.AsEnumerable(); }
@@ -195,7 +203,7 @@ public bool Equals(Table other)
         {
             if (ReferenceEquals(null, other)) return false;
             if (ReferenceEquals(this, other)) return true;
-            return Equals(other._actualName, _actualName) && Equals(other._schema, _schema) && Equals(other._type, _type);
+            return Equals(other._actualName, _actualName) && Equals(other._schema, _schema) && Equals(other._type, _type) && Equals(other._aliasedTable, _aliasedTable);
         }
 
         /// <summary>
diff --git a/Simple.Data.SqlServer/Properties/Resources.Designer.cs b/Simple.Data.SqlServer/Properties/Resources.Designer.cs
index c9ed52f6..811ddb82 100644
--- a/Simple.Data.SqlServer/Properties/Resources.Designer.cs
+++ b/Simple.Data.SqlServer/Properties/Resources.Designer.cs
@@ -1,7 +1,7 @@
 //------------------------------------------------------------------------------
 // <auto-generated>
 //     This code was generated by a tool.
-//     Runtime Version:4.0.30319.1
+//     Runtime Version:4.0.30319.18408
 //
 //     Changes to this file may cause incorrect behavior and will be lost if
 //     the code is regenerated.
@@ -90,5 +90,37 @@ internal static string PrimaryKeySql {
                 return ResourceManager.GetString("PrimaryKeySql", resourceCulture);
             }
         }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to select rc.CONSTRAINT_NAME, fkcu.TABLE_SCHEMA,&apos;{0}&apos; As TABLE_NAME, fkcu.COLUMN_NAME,
+        ///pkcu.TABLE_SCHEMA AS UNIQUE_TABLE_SCHEMA, pkcu.TABLE_NAME AS UNIQUE_TABLE_NAME, pkcu.COLUMN_NAME AS UNIQUE_COLUMN_NAME,
+        ///fkcu.ORDINAL_POSITION
+        ///FROM  {1}INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
+        ///JOIN  {1}INFORMATION_SCHEMA.KEY_COLUMN_USAGE fkcu ON rc.CONSTRAINT_NAME = fkcu.CONSTRAINT_NAME
+        ///JOIN  {1}INFORMATION_SCHEMA.KEY_COLUMN_USAGE pkcu ON rc.UNIQUE_CONSTRAINT_NAME = pkcu.CONSTRAINT_NAME
+        ///WHERE fkcu.ORDINAL_POSITION  [rest of string was truncated]&quot;;.
+        /// </summary>
+        internal static string RemoteForeignKeysSql {
+            get {
+                return ResourceManager.GetString("RemoteForeignKeysSql", resourceCulture);
+            }
+        }
+        
+        /// <summary>
+        ///   Looks up a localized string similar to select kcu.TABLE_SCHEMA, &apos;{0}&apos; As TABLE_NAME, kcu.CONSTRAINT_NAME, tc.CONSTRAINT_TYPE, kcu.COLUMN_NAME, kcu.ORDINAL_POSITION
+        ///  from {1}INFORMATION_SCHEMA.TABLE_CONSTRAINTS as tc
+        ///  join {1}INFORMATION_SCHEMA.KEY_COLUMN_USAGE as kcu
+        ///    on kcu.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
+        ///   and kcu.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
+        ///   and kcu.TABLE_SCHEMA = tc.TABLE_SCHEMA
+        ///   and kcu.TABLE_NAME = tc.TABLE_NAME
+        /// where tc.CONSTRAINT_TYPE = &apos;PRIMARY KEY&apos;
+        /// AND upper(kcu.table_name) = upper(&apos;{2}&apos;).
+        /// </summary>
+        internal static string RemotePrimaryKeySql {
+            get {
+                return ResourceManager.GetString("RemotePrimaryKeySql", resourceCulture);
+            }
+        }
     }
 }
diff --git a/Simple.Data.SqlServer/Properties/Resources.resx b/Simple.Data.SqlServer/Properties/Resources.resx
index dea94da3..9d6a0ecc 100644
--- a/Simple.Data.SqlServer/Properties/Resources.resx
+++ b/Simple.Data.SqlServer/Properties/Resources.resx
@@ -124,4 +124,10 @@
   <data name="PrimaryKeySql" type="System.Resources.ResXFileRef, System.Windows.Forms">
     <value>..\Resources\PrimaryKeySql.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
   </data>
+  <data name="RemoteForeignKeysSql" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\RemoteForeignKeysSql.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;Windows-1252</value>
+  </data>
+  <data name="RemotePrimaryKeySql" type="System.Resources.ResXFileRef, System.Windows.Forms">
+    <value>..\Resources\RemotePrimaryKeySql.txt;System.String, mscorlib, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089;utf-8</value>
+  </data>
 </root>
\ No newline at end of file
diff --git a/Simple.Data.SqlServer/Simple.Data.SqlServer.csproj b/Simple.Data.SqlServer/Simple.Data.SqlServer.csproj
index 87873058..c97aab71 100644
--- a/Simple.Data.SqlServer/Simple.Data.SqlServer.csproj
+++ b/Simple.Data.SqlServer/Simple.Data.SqlServer.csproj
@@ -95,6 +95,12 @@
   <ItemGroup>
     <None Include="Resources\ForeignKeysSql.txt" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\RemotePrimaryKeySql.txt" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="Resources\RemoteForeignKeysSql.txt" />
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.
diff --git a/Simple.Data.SqlServer/SqlSchemaProvider.cs b/Simple.Data.SqlServer/SqlSchemaProvider.cs
index 9d022670..30df9e01 100644
--- a/Simple.Data.SqlServer/SqlSchemaProvider.cs
+++ b/Simple.Data.SqlServer/SqlSchemaProvider.cs
@@ -10,12 +10,22 @@ namespace Simple.Data.SqlServer
 {
     class SqlSchemaProvider : ISchemaProvider
     {
+        enum ObjectNamePart
+        {
+            Name = 1,
+            Schema = 2,
+            Database = 3,
+            Server = 4
+        }
+
         private readonly IConnectionProvider _connectionProvider;
+        private IEnumerable<Tuple<string, string, string>> _synonyms;
 
         public SqlSchemaProvider(IConnectionProvider connectionProvider)
         {
             if (connectionProvider == null) throw new ArgumentNullException("connectionProvider");
             _connectionProvider = connectionProvider;
+            _synonyms = getSynonyms();
         }
 
         public IConnectionProvider ConnectionProvider
@@ -25,7 +35,15 @@ public IConnectionProvider ConnectionProvider
 
         public IEnumerable<Table> GetTables()
         {
-            return GetSchema("TABLES").Select(SchemaRowToTable);
+            var tables = GetSchema("TABLES").Select(SchemaRowToTable);
+            //Add Synonyms a table to the tables list
+            List<Table> synTables = new List<Table>();
+            foreach (var syn in _synonyms.Where(s => s.Item3 == "U" || s.Item3 == "V"))
+                synTables.Add(new Table(syn.Item1, getObjectPart(syn.Item2, ObjectNamePart.Schema)
+                    , syn.Item3 == "U" ? TableType.Table : TableType.View
+                    , getObjectPart(syn.Item2, ObjectNamePart.Name)));
+
+            return tables.Union(synTables);
         }
 
         private static Table SchemaRowToTable(DataRow row)
@@ -37,10 +55,34 @@ private static Table SchemaRowToTable(DataRow row)
         public IEnumerable<Column> GetColumns(Table table)
         {
             if (table == null) throw new ArgumentNullException("table");
-            var cols = GetColumnsDataTable(table);
-            return cols.AsEnumerable().Select(row => SchemaRowToColumn(table, row));
+            //if this table is a synonym, get columns from real table
+            if (!string.IsNullOrEmpty(table.AliasedTable))
+                return GetColumnsFromSchemaQuery(table).AsEnumerable().Select(row => SynonymSchemaRowToColumn(table, row));
+            else
+                return GetColumnsDataTable(table).AsEnumerable().Select(row => SchemaRowToColumn(table, row));
         }
 
+        private static Column SynonymSchemaRowToColumn(Table table, DataRow row)
+        {
+            SqlDbType sqlDbType = SqlDbType.Udt;
+
+            if (!row.IsNull("DataTypeName"))
+                sqlDbType = DbTypeFromInformationSchemaTypeName((string)row["DataTypeName"]);
+
+            var size = (int)row["ColumnSize"];
+            switch (sqlDbType)
+            {
+                case SqlDbType.Image:
+                case SqlDbType.NText:
+                case SqlDbType.Text:
+                    size = -1;
+                    break;
+            }
+
+            return new SqlColumn(row["ColumnName"].ToString(), table, (bool)row["IsIdentity"], sqlDbType, size);
+        }
+
+
         private static Column SchemaRowToColumn(Table table, DataRow row)
         {
             SqlDbType sqlDbType = SqlDbType.Udt;
@@ -67,7 +109,13 @@ private static Column SchemaRowToColumn(Table table, DataRow row)
 
         public IEnumerable<Procedure> GetStoredProcedures()
         {
-            return GetSchema("Procedures").Select(SchemaRowToStoredProcedure);
+            var sprocs = GetSchema("Procedures").Select(SchemaRowToStoredProcedure);
+            //Add Synonyms a sproc to the sproc list
+            List<Procedure> synProcs = new List<Procedure>();
+            foreach (var syn in _synonyms.Where(s => s.Item3 == "P"))
+                synProcs.Add(new Procedure(syn.Item1, syn.Item1, string.Empty, syn.Item2));
+
+            return sprocs.Union(synProcs);
         }
 
         private IEnumerable<DataRow> GetSchema(string collectionName, params string[] constraints)
@@ -87,6 +135,9 @@ private static Procedure SchemaRowToStoredProcedure(DataRow row)
 
         public IEnumerable<Parameter> GetParameters(Procedure storedProcedure)
         {
+            //support for aliased storec procedure names (synonyms)
+            var sprocName = string.IsNullOrEmpty(storedProcedure.AliasedProcedure) ? storedProcedure.QualifiedName
+                : storedProcedure.AliasedProcedure;
             // GetSchema does not return the return value of e.g. a stored proc correctly,
             // i.e. there isn't sufficient information to correctly set up a stored proc.
             using (var connection = (SqlConnection)ConnectionProvider.CreateConnection())
@@ -94,7 +145,7 @@ public IEnumerable<Parameter> GetParameters(Procedure storedProcedure)
                 using (var command = connection.CreateCommand())
                 {
                     command.CommandType = CommandType.StoredProcedure;
-                    command.CommandText = storedProcedure.QualifiedName;
+                    command.CommandText = sprocName;
 
                     connection.Open();
                     SqlCommandBuilder.DeriveParameters(command);
@@ -109,7 +160,8 @@ public IEnumerable<Parameter> GetParameters(Procedure storedProcedure)
         public Key GetPrimaryKey(Table table)
         {
             if (table == null) throw new ArgumentNullException("table");
-            var primaryKeys = GetPrimaryKeys(table.ActualName);
+            var tableName = table.ActualName;
+            var primaryKeys = GetPrimaryKeys(tableName);
             if (primaryKeys == null)
             {
                 return new Key(Enumerable.Empty<string>());
@@ -117,7 +169,7 @@ public Key GetPrimaryKey(Table table)
             return new Key(primaryKeys.AsEnumerable()
                 .Where(
                     row =>
-                    row["TABLE_SCHEMA"].ToString() == table.Schema && row["TABLE_NAME"].ToString() == table.ActualName)
+                    row["TABLE_SCHEMA"].ToString() == table.Schema && row["TABLE_NAME"].ToString() == tableName)
                     .OrderBy(row => (int)row["ORDINAL_POSITION"])
                     .Select(row => row["COLUMN_NAME"].ToString()));
         }
@@ -125,9 +177,10 @@ public Key GetPrimaryKey(Table table)
         public IEnumerable<ForeignKey> GetForeignKeys(Table table)
         {
             if (table == null) throw new ArgumentNullException("table");
-            var groups = GetForeignKeys(table.ActualName)
+            var tableName = table.ActualName;
+            var groups = GetForeignKeys(tableName)
                 .Where(row =>
-                    row["TABLE_SCHEMA"].ToString() == table.Schema && row["TABLE_NAME"].ToString() == table.ActualName)
+                    row["TABLE_SCHEMA"].ToString() == table.Schema && row["TABLE_NAME"].ToString() == tableName)
                 .GroupBy(row => row["CONSTRAINT_NAME"].ToString())
                 .ToList();
 
@@ -162,20 +215,71 @@ public Type DataTypeToClrType(string dataType)
         private DataTable GetColumnsDataTable(Table table)
         {
             const string columnSelect = @"SELECT name, is_identity, type_name(system_type_id) as type_name, max_length from sys.columns 
-where object_id = object_id(@tableName, 'TABLE') or object_id = object_id(@tableName, 'VIEW') order by column_id";
+                where object_id = object_id(@tableName, 'TABLE') or object_id = object_id(@tableName, 'VIEW') order by column_id";
             var @tableName = new SqlParameter("@tableName", SqlDbType.NVarChar, 128);
             @tableName.Value = string.Format("[{0}].[{1}]", table.Schema, table.ActualName);
             return SelectToDataTable(columnSelect, @tableName);
         }
 
+        private DataTable GetColumnsFromSchemaQuery(Table table)
+        {
+            DataTable dt = new DataTable();
+            using (var cn = ConnectionProvider.CreateConnection() as SqlConnection)
+            {
+                string commandText = string.Format("select top 1 * from {0}", table.QualifiedName);
+                using (SqlCommand cmd = new SqlCommand(commandText, cn))
+                {
+                    cmd.CommandType = CommandType.Text;
+                    cn.Open();
+                    SqlDataReader dr = cmd.ExecuteReader(CommandBehavior.CloseConnection);
+                    return dr.GetSchemaTable();
+                }
+            }
+        }
+
         private DataTable GetPrimaryKeys()
         {
-            return SelectToDataTable(Properties.Resources.PrimaryKeySql);
+            var dt = SelectToDataTable(Properties.Resources.PrimaryKeySql);
+            //get pks for synonym tables
+            foreach (var syn in _synonyms.Where(s => s.Item3 == "U" || s.Item3 == "V"))
+            {
+                DataTable remoteTable = GetRemotePrimaryKey(syn.Item1, syn.Item2);
+                if (remoteTable.Rows.Count > 0)
+                    dt.Merge(remoteTable);
+            }
+            return dt;
+        }
+
+        private DataTable GetRemotePrimaryKey(string tableName, string remoteTableName)
+        {
+            return SelectToDataTable(string.Format(Properties.Resources.RemotePrimaryKeySql
+                , tableName
+                , getObjectPart(remoteTableName, ObjectNamePart.Server) + "." + getObjectPart(remoteTableName, ObjectNamePart.Database) + "."
+                , getObjectPart(remoteTableName, ObjectNamePart.Name)));
         }
 
         private DataTable GetForeignKeys()
         {
-            return SelectToDataTable(Properties.Resources.ForeignKeysSql);
+            var dt = SelectToDataTable(Properties.Resources.ForeignKeysSql);
+            //get fks for synonym tables
+            foreach (var syn in _synonyms.Where(s => s.Item3 == "U" || s.Item3 == "V"))
+            {
+                DataTable remoteTable = GetRemoteForeignKeys(syn.Item1, syn.Item2);
+                if (remoteTable.Rows.Count > 0)
+                    dt.Merge(remoteTable);
+            }
+            return dt;
+        }
+
+        private DataTable GetRemoteForeignKeys(string tableName, string remoteTableName)
+        {
+            var serverName = getObjectPart(remoteTableName, ObjectNamePart.Server);
+            var databaseName = getObjectPart(remoteTableName, ObjectNamePart.Database);
+            return SelectToDataTable(string.Format(Properties.Resources.RemoteForeignKeysSql
+               , tableName
+               , serverName + "." + databaseName + "."
+               , "[" + serverName + "].[" + databaseName + "]."
+               , getObjectPart(remoteTableName, ObjectNamePart.Name)));
         }
 
         private DataTable GetPrimaryKeys(string tableName)
@@ -230,5 +334,37 @@ public String GetDefaultSchema()
         {
             return "dbo";
         }
+
+        private IEnumerable<Tuple<string, string, string>> getSynonyms()
+        {
+            const string synSelect = @"SELECT name, base_object_name, OBJECTPROPERTYEX(OBJECT_ID(name), 'BaseType') AS BaseType FROM SYS.SYNONYMS;";
+            var dataTable = new DataTable();
+            using (var cn = ConnectionProvider.CreateConnection() as SqlConnection)
+            {
+                using (var adapter = new SqlDataAdapter(synSelect, cn))
+                {
+                    adapter.Fill(dataTable);
+                }
+            }
+            foreach (DataRow row in dataTable.Rows)
+                yield return new Tuple<string, string, string>(row["name"].ToString(), row["base_object_name"].ToString(), row["BaseType"].ToString().Trim());
+        }
+
+        private string getObjectPart(string fullObjectName, ObjectNamePart objectNamePart)
+        {
+            if (!fullObjectName.Contains('.'))
+                return fullObjectName;
+
+            var objParts = fullObjectName.Split('.');
+            if (objParts.Length < (int)objectNamePart)
+            {
+                if (objectNamePart == ObjectNamePart.Schema)
+                    return GetDefaultSchema();
+                else
+                    return string.Empty;
+            }
+            string result = objParts[objParts.Length - (int)objectNamePart];
+            return result.Replace("[", string.Empty).Replace("]", string.Empty);
+        }
     }
 }