ADO.net senza scrivere SQL (esp.DOVE)

StackOverflow https://stackoverflow.com/questions/604430

Domanda

Io sono di questa idea che l'utilizzo di SQL VISTA astratto di database semplici calcoli (come contare su una relazione), è sufficiente, e non avete bisogno di procedure (== codice procedurale)

Una semplice sql vista + un dove clausola di >> una stored procedure con parametri a volte

Mentre rendendo questo punto ho immaginato un modo di recuperare tabella/vista i dati senza la scrittura SQL e senza scrivere la clausola where..

Ma, con mia sorpresa, non ci sembra un modo per eseguire questa operazione in ADO.NET 2.0 o versione successiva.

Permettetemi di dirvi cosa ho provato:

  • SqlDataAdapter + SqlCommandBuilder richiede ancora di scrivere "SELECT ...DA" e l' CLAUSOLA WHERE in stringhe (più, se si mette la 'dove', non hai molto uso di Update/Insert/Delete)

  • i Dataset tipizzati solo consentono di recuperare _entire DataTable_s e quindi l'applicazione di filtri.I filtri sono stringhe, senza uscire di aiuto...(deve raddoppiare la singola citazione!)

  • SQL a Soggetti che sembrava promettente, ma sembrano:essere limitato a MSSQL, generare gonfio di query SQL, generare un nuovo stack di Tao (oltre al Modello di Dominio esistente classi), reqiuire .net 3.5+ per tutto questo, etc.(che è, tutti questi sono gli svantaggi per me)

Altri Orm hanno problemi simili a quelli di SQL e le Entità.

Quello che sto cercando è un tipizzato metodo di accesso a tabelle di database/vista che:

  • non venire con un'altra serie di Tao (K. I. S. S)
  • mi permette di eseguire query in una tabella senza scrivere "Seleziona" in stringhe (strong-typed)
  • mi permette di filtro(DOVE) una tabella con correttamente escape parametri (e senza il recupero di tutti i dati in anticipo)
  • in seguito possono rilasciare aggiornamenti/inserimenti/cancellazioni

Io sono abbastanza nuovo .Net ma non stupido:questo non esiste?

Grazie.

È stato utile?

Soluzione

Subsonico è abbastanza leggero strumento di query che è possibile utilizzare per eseguire direttamente le query su database con una Query oggetto abstract SQL.Se si desidera, è possibile utilizzare anche il codice impianto di generazione di mappare le tabelle del database in POCOs, o di creare un solo fortemente tipizzato schema (per la colonna nomi di tabelle e così via).

Altri suggerimenti

Io non credo che quello che vuoi fare è realizzabile senza l'utilizzo di una sorta di ORM o specializzata DSL con un compilatore che in qualche modo sa circa lo schema del database, tipo/colonna di informazioni, etc.

Prendere in considerazione che il C# è un uso generale della lingua, e il suo compilatore è totalmente all'oscuro dei vostri tipi di database, ecco perché non si può associare loro senza l'utilizzo di alcuni layer di astrazione, che di solito comporta la query SQL ad hoc(stringhe), NHibernate o simili file di mapping (più stringhe) e/o Tao.

Se non si desidera scrivere la clausola WHERE, un modo è quello di utilizzare un oggetto Filtro e aggiungere le condizioni che si desidera.Per esempio:

        var sc = new Filter();
        sc.Add("Contacttitle", "Sales Agent");
        sc.Add("city", "london", Logical.Or);
        var customers = D2Bk.Fetch(sc, new Customers());

Ma non si desidera utilizzare Tao (i Clienti di cui sopra è tale), così si dovrebbe scrivere l'istruzione SQL e specificare la clausola where:

        DataSet ds = D2Bk.Fetch("SELECT * FROM Customers WHERE Contacttitle=@PAR1 OR City=@PAR2", "Sales Agent", "london");

Io presumo che hai guardato LINQ e ADO.Net Servizi Di Dati e questi non soddisfano alcuni requisiti?

Nativo ADO.Net è un provider di database, e quindi offre un collegamento diretto con interfaccia SQL in origini dati sottostanti.Ci sono diversi CRUB soluzioni là fuori che consentono di simulare quello che suggeriscono a vari gradi.

Abbiamo un forte trend di lasciare il database per il Database di squadra e utilizzare Servizi web come interfaccia principale del nostro database, principalmente a causa di un Delphi codebase che ancora hanno bisogno di essere supportati.

In realtà non posso credere che mi sono dimenticato di aggiungere ADO.Net Entity Framework che è usato da ADO.Net Servizi di Dati, tra gli altri.C'è anche un LINQ to Entities provider.

Ho fatto qualcosa di simile con una stored procedure una volta.Fondamentalmente, volevo specificare ogni permutazione di campi da corrispondere nel mio clausola WHERE, ma non ho voglia di scrivere 100 sprocs leggermente diversi param liste e dove clausole.

Così, ho fatto qualcosa di simile a questo:

CREATE PROCEDURE [GetSimpleCustomers]
(
@ID varchar(50) = null,
@Name varchar(50) = null,
@IsActive  bit = null,
@Address1 varchar(50) = null,
@Address2 varchar(50) = null,
@City varchar(50) = null,
@State varchar(50) = null,
@Zip varchar(50) = null
)
AS

SELECT ID, Name, IsActive, Address1, Address2, City, State, Zip
FROM SimpleCustomerExample
WHERE (ID = @ID OR @ID is NULL)
AND (Name = @Name OR @Name is NULL)
AND (IsActive = @IsActive or @IsActive is NULL)
AND (Address1= @Address1 or @Address1 is NULL)
AND (Address2= @Address2 or @Address2 is NULL)
AND (City= @City or @City is NULL)
AND (State= @State or @State is NULL)
AND (Zip= @Zip or @Zip is NULL)

Questo vi permetterà di chiamare la stored procedure nel codice e pass solo params siete interessati a filtro, e il resto non saranno presi in considerazione se si lascia loro null.

Così, si può fare qualcosa di simile 

public List<SimpleCustomer> GetAllCustomersFromOhio()
{
    List<SimpleCustomer> list = new List<SimpleCustomer>();
    using (SqlCommand cmd = new SqlCommand(blah blah))
    {
        cmd.Parameters.AddWithValue("State", "Ohio");//or "OH" depending on your convention
        using(IDataReader oDR = cmd.ExecuteReader())
        {
             //hydrate your list of SimpleCustomers from the record set.
        }
    }
    return list;
}

EDIT:In risposta al commento:Si potrebbe abbastanza facilmente alterare il GetSimpleCustomers essere DeleteSimpleCustomers cambiando il 

SELECT <columns> FROM SimpleCustomers

per 

DELETE FROM SimpleCustomers

e mantenere la stessa logica.Lo stesso vale per un Aggiornamento.Inoltre, ho intenzione di rispondere a una domanda con una domanda:Quanti tavoli hai effettivamente bisogno di questo livello di personalizzazione dei filtri?La sintassi dovrebbe essere così simile si potrebbe sterlina tutto in un giorno (o meno se si martellato insieme un semplice script per scrivere per voi).

Se si utilizza fortemente tipizzato set di dati, è possibile creare query con parametri nell'Editor di Visual Studio, aggiungendo identificatori il prefisso @ nella query.Creare un set di dati XSD file in Visual Studio e creare una nuova tabella denominata Prodotti, quindi aggiungere una nuova query ad esso.

Per esempio:

select * from Products where Category = @category;

Questo genera automaticamente i metodi per il pieno di set di dati o di ottenere datatable prendere il parametro aggiuntivo.Sarà, inoltre, di gestire correttamente la fuga corde (utilizza parametri di oggetti di comando).Ho usato questo per creare un super semplice prototipo di web apps abbastanza rapidamente.

Recentemente ho scritto una query "quadro di riferimento" per la generazione di SQL where.

Il componente principale è un BaseQueryArgs classe con un ToWhereClause() funzione che utilizza la riflessione per la conversione proprietà in stringa sezioni.Questo deve gestire il lavoro di fuga e correttamente la formattazione di valori.

Qualsiasi classe che eredita BaseQueryArgs deve semplicemente dichiarare di proprietà pubbliche, e si finisce con un tipizzata oggetto query.Per le proprietà facoltative, il valore nullable (ref type o Nullable<>) e SQL generatore filtra i valori null.

È possibile utilizzare gli attributi personalizzati per definire funzioni extra per ogni struttura:

  • colonna personalizzata nome diverso dal nome della proprietà
  • valore personalizzato di gestione (ad esempio una data valore viene utilizzato come TRA l'espressione di test)

Questo può essere utilizzato per la creazione di query con un tipizzata in oggetto query in questo modo:

MyCustomQueryArgs args = new MyCustomQueryArgs
{
    ProductFamilyID = 17,
    Region = Regions.Northwest,
    Active = true
};

List<Product> product = QueryProcessor.GetProductsWhere(args);

GetProductsWhere() sarebbe, ovviamente, un certo tipo di metodo di dati che accede a vista con SQL generato.

Non ho una soluzione per gli aggiornamenti e le elimina, ma non mi sembra che il duro scrittura di un metodo che converte l'istanza di un oggetto in una istruzione SQL per mezzo di un interruttore o di un attributo per determinare il nome della tabella.

Questo è molto "roll your own", ma che ti dà la libertà di personalizzare per le vostre esigenze, e non include un sacco di pioggia e ORM/DAO avvolgimento.

Guarda Mindscapes Lightspeed prodotti

Esso si basa stongly digitato LINQ queriable modelli che si traduce in efficienza il codice SQL attraverso una varietà di motori di database e comprende Memcached e Lucene supporto

Ho usato XPO su diversi progetti e la loro versione più recente è il supporto per le query.

http://www.devexpress.com/Products/NET/ORM/

L'attuazione, come tutti, non senza i suoi inconvenienti, però.

Io uso Dati Astratti per i miei progetti.

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top