Bewerten Sie in T-SQL

Es gibt kein "ordentlicher" Weg, dies zu tun. Sie sparen Zeit, wenn Sie akzeptieren es und schaut auf etwas anderes.

EDIT: Aha! Über die OP ' s Kommentar, dass "Wir haben Sie zum laden von Daten in eine neue Datenbank jeden Monat oder sonst wird es zu groß.". Erstaunlich im Nachhinein, dass niemand bemerkte den schwachen Geruch von diesem problem.

SQL Server bietet nativen Mechanismen für den Umgang mit Tabellen erhalten Sie "zu groß" ist (insbesondere, Partitionierung), die Ihnen erlauben, um die Adresse der Tabelle als eine Einheit, während die Aufteilung der Tabelle in separaten Dateien im hintergrund, so dass Sie Ihre aktuellen problem zusammen.

Um es anders auszudrücken, dies ist ein problem für Ihre DB-administrator, nicht der DB-consumer. Wenn das passiert, werden Sie als gut, ich schlage vor, Sie schauen in partitionieren dieser Tabelle.

Können Sie nicht angeben, eine dynamische Tabellennamen im SQL-Server.

Gibt es ein paar Optionen:

1. Dynamisches SQL verwenden
2. Spielen, um mit Synonymen (das heißt, weniger dynamische SQL, aber immer noch einige)

Du hast gesagt, dass Sie nicht wie 1, also lets go für die 2.

Erste Möglichkeit ist die Beschränkung der messyness eine Zeile:

begin transaction t1;
declare @statement nvarchar(100);

set @statement = 'create synonym temptablesyn for db1.dbo.test;'
exec sp_executesql @statement

select * from db_syn

drop synonym db_syn;

rollback transaction t1;

Ich bin mir nicht sicher, ich mag diese, aber es kann die beste option sein. Auf diese Weise werden alle der Wählt wird die gleiche sein.

Können Sie diese umgestalten, um Eure Herzen Inhalte, aber es gibt eine Reihe von Nachteilen auf, einschließlich das synonym erstellt wird in einer Transaktion, so dass Sie nicht zwei
die Abfragen laufen auf dem gleichen
Zeit (da beide versuchen werden
erstellen temptablesyn). Je
auf der locking-Strategie, wird man
blockieren die anderen.

Synonyme sind permanent, also das ist, warum müssen Sie dies tun, in einer Transaktion.

Nur ein Gedanke, aber wenn Sie eine vordefinierte Liste dieser Datenbanken ist, dann können Sie eine einzelne Ansicht in der Datenbank, die Sie verbinden, sich Ihnen anzuschließen - so etwas wie:

CREATE VIEW dbo.all_tables
AS

SELECT  your_columns,
        'db_name1' AS database_name
FROM    db_name1.dbo.your_table

UNION ALL

SELECT  your_columns,
        'db_name2'
FROM    db_name2.dbo.your_table

etc...

Dann könnten Sie übergeben den Namen Ihrer Datenbank in der gespeicherten Prozedur, und benutzt es einfach als Parameter in der WHERE-Klausel. Wenn die Tabellen groß sind, könnten Sie erwägen Sie die Verwendung einer indizierten Sicht, indexiert auf das neue database_name Spalte (oder was auch immer Sie es nennen), und die Tische' primary key (ich gehe davon aus die Frage, der Tabellen-schemas sind die gleichen?).

Natürlich, wenn Sie Ihre Liste der Datenbank Häufig ändert, dann wird das immer problematisch - aber wenn Sie zum erstellen dieser Datenbanken sowieso, dann die Aufrechterhaltung dieser Ansicht zur gleichen Zeit sollte nicht zu viel von einem Aufwand!

Könnte man erstellen Sie eine SQL-CLR-tabellenwertfunktionen UDF, um den Zugriff auf die Tabellen. Sie haben sich zu binden, um das schema, da TV-UDFs nicht unterstützt dynamisches schema. (Mein Beispiel beinhaltet eine ID und eine Spalte Titel - ändern Sie die für Ihre Bedürfnisse)

Sobald Sie dies getan haben, sollten Sie in der Lage zu tun, die follow-Abfrage:

SELECT * FROM dbo.FromMyTable('table1')

Können Sie ein mehrteiliger name, in string zu.

SELECT * FROM dbo.FromMyTable('otherdb..table1')

zurück die ID,den Titel Spalten aus dieser Tabelle.

Werden Sie wahrscheinlich benötigen, um SQL-CLR und schalten Sie die option TRUSTWORTHY:

sp_configure 'clr enabled',1
go
reconfigure
go
alter database mydatabase set trustworthy on

Erstellen Sie eine C# - SQL-Projekt, fügen Sie eine neue UDF-Datei, fügen Sie diese in es. Project Eigenschaft, Datenbank, Genehmigung Ebene externe. Erstellen, bereitstellen. Gemacht werden kann, ohne VisualStudio. Lassen Sie mich wissen, wenn Sie das brauchen.

using System;
using System.Data.SqlTypes;
using Microsoft.SqlServer.Server;
using System.Collections;
using System.Data.SqlClient;

[assembly: CLSCompliant(true)]
namespace FromMyTable
{
    public static partial class UserDefinedFunctions
    {
        [Microsoft.SqlServer.Server.SqlFunction(DataAccess = DataAccessKind.Read, IsDeterministic = true, SystemDataAccess = SystemDataAccessKind.Read, IsPrecise = true, FillRowMethodName = "FillRow", 
            TableDefinition = "id int, title nvarchar(1024)")]
        public static IEnumerable FromMyTable(SqlString tableName)
        {
            return new FromMyTable(tableName.Value);
        }

        public static void FillRow(object row, out SqlInt32 id, out SqlString title)
        {
            MyTableSchema v = (MyTableSchema)row;
            id = new SqlInt32(v.id);
            title = new SqlString(v.title);
        }
    }

    public class MyTableSchema
    {
        public int id;
        public string title;
        public MyTableSchema(int id, string title) { this.id = id; this.title = title; }
    }

    internal class FromMyTable : IEnumerable
    {
        string tableName;

        public FromMyTable(string tableName)
        {
            this.tableName = tableName;
        }

        public IEnumerator GetEnumerator()
        {
            return new FromMyTableEnum(tableName);
        }
    }

    internal class FromMyTableEnum : IEnumerator
    {
        SqlConnection cn;
        SqlCommand cmd;
        SqlDataReader rdr;
        string tableName;

        public FromMyTableEnum(string tableName)
        {
            this.tableName = tableName;
            Reset();
        }

        public MyTableSchema Current
        {
            get { return new MyTableSchema((int)rdr["id"], (string)rdr["title"]); }
        }

        object IEnumerator.Current
        {
            get { return Current; }
        }

        public bool MoveNext()
        {
            bool b = rdr.Read();
            if (!b) { rdr.Dispose(); cmd.Dispose(); cn.Dispose(); rdr = null; cmd = null; cn = null; }
            return b;
        }

        public void Reset()
        {
            // note: cannot use a context connection here because it will be closed
            // in between calls to the enumerator.
            if (cn == null) { cn = new SqlConnection("server=localhost;database=mydatabase;Integrated Security=true;"); cn.Open(); }
            if (cmd == null) cmd = new SqlCommand("select id, title FROM " + tableName, cn);
            if (rdr != null) rdr.Dispose();
            rdr = cmd.ExecuteReader();
        }
    }
}

Wenn Sie eine einigermaßen überschaubare Anzahl von Datenbanken, kann es am besten verwenden Sie einen pre-definiert bedingte Anweisung wie:

if (@dbname = 'db1')
  select * from db1..MyTable
if (@dbname = 'db2')
  select * from db2..MyTable
if (@dbname = 'db3')
  select * from db3..MyTable

...

generieren Sie mit diesem proc-als Teil der Erstellung der Datenbank-Skripts wenn Sie die änderung der Liste der verfügbaren Datenbanken Abfragen.

Dies verhindert Sicherheitsprobleme mit dynamischem sql. Sie können auch verbessern Sie die Leistung durch den Austausch der 'select' - Anweisungen mit gespeicherten Prozeduren auf jeden Datenbank - (1-Cache execution plan pro Abfrage).