it-swarm.it

Esportare i dati delle query SQL in Excel

Ho una query che restituisce un set di dati molto grande. Non riesco a copiarlo e incollarlo in Excel, cosa che di solito faccio. Ho fatto alcune ricerche su come esportare direttamente su un foglio Excel. Sto eseguendo SQL SERVER 2008 su un server che esegue Microsoft Server 2003. Sto cercando di utilizzare il fornitore di dati Microsoft.Jet.OLEDB.4.0 ed Excel 2007. Ho messo insieme una piccola porzione di codice simile a quella di I Ho visto in esempi.

INSERT INTO OPENDATASOURCE('Microsoft.Jet.OLEDB.4.0',
'Data Source=C:\Working\Book1.xlsx;Extended Properties=Excel 12.0;HDR=YES')
SELECT productid, price FROM dbo.product

Tuttavia questo non funziona, sto ricevendo un messaggio di errore che dice 

"Sintassi errata vicino alla parola chiave 'SELECT'".

Qualcuno ha qualche idea su come fare questo o forse un approccio migliore?

23
JBone

Non so se questo è quello che stai cercando, ma puoi esportare i risultati in Excel in questo modo:

Nel riquadro dei risultati, fai clic sulla cella in alto a sinistra per evidenziare tutti i record, quindi fai clic con il pulsante destro del mouse sulla cella in alto a sinistra e fai clic su "Salva risultati con nome". Una delle opzioni di esportazione è CSV.

Puoi dare una possibilità anche a questo:

INSERT INTO OPENROWSET 
   ('Microsoft.Jet.OLEDB.4.0', 
   'Excel 8.0;Database=c:\Test.xls;','SELECT productid, price FROM dbo.product')

Infine, puoi utilizzare SSIS (sostituito DTS) per l'esportazione dei dati. Ecco un link a un tutorial:

http://www.accelebrate.com/sql_training/ssis_2008_tutorial.htm

45
James Johnson

Se hai solo bisogno di esportare in Excel, puoi utilizzare la procedura guidata di esportazione dei dati. Fare clic con il tasto destro del mouse sul database, Attività-> Esporta dati. 

15
brian

Ho avuto un problema simile ma con una svolta: le soluzioni sopra elencate funzionavano quando il set di risultati proveniva da una query, ma nella mia situazione, avevo più query di selezione individuali per le quali avevo bisogno di risultati da esportare in Excel. Di seguito è solo un esempio da illustrare anche se potrei fare una clausola name in ...

select a,b from Table_A where name = 'x'
select a,b from Table_A where name = 'y'
select a,b from Table_A where name = 'z'

La procedura guidata mi consentiva di esportare il risultato da una query in Excel ma non tutti i risultati di query diverse in questo caso. 

Quando ho effettuato una ricerca, ho scoperto che potremmo disabilitare i risultati nella griglia e abilitare i risultati in Testo. Quindi, premi Ctrl + T, quindi esegui tutte le istruzioni. Questo dovrebbe mostrare i risultati come un file di testo nella finestra di output. Puoi manipolare il testo in un formato delimitato da tabulazioni per poterlo importare in Excel. 

Puoi anche premere Ctrl + Shift + F per esportare i risultati in un file - esporta come file .rpt che può essere aperto usando un editor di testo e manipolato per l'importazione di Excel.

Spero che questo aiuti gli altri che hanno un problema simile.

1
Prashanth

Per chi viene qui a cercare come farlo in C #, ho provato il seguente metodo e ho avuto successo con dotnet core 2.0.3 e entity framework core 2.0.3

Prima crea la tua classe modello.

public class User
{  
    public string Name { get; set; }  
    public int Address { get; set; }  
    public int Zip { get; set; }  
    public string Gender { get; set; }  
} 

Quindi installa Pacchetto EPPlus Nuget . (Ho usato la versione 4.0.5, probabilmente funzionerà anche per altre versioni.)

Install-Package EPPlus -Version 4.0.5

Crea la classe ExcelExportHelper, che conterrà la logica per convertire il set di dati in righe di Excel. Questa classe non ha dipendenze con la classe del modello o il set di dati. 

public class ExcelExportHelper
    {
        public static string ExcelContentType
        {
            get
            { return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"; }
        }

        public static DataTable ListToDataTable<T>(List<T> data)
        {
            PropertyDescriptorCollection properties = TypeDescriptor.GetProperties(typeof(T));
            DataTable dataTable = new DataTable();

            for (int i = 0; i < properties.Count; i++)
            {
                PropertyDescriptor property = properties[i];
                dataTable.Columns.Add(property.Name, Nullable.GetUnderlyingType(property.PropertyType) ?? property.PropertyType);
            }

            object[] values = new object[properties.Count];
            foreach (T item in data)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    values[i] = properties[i].GetValue(item);
                }

                dataTable.Rows.Add(values);
            }
            return dataTable;
        }

        public static byte[] ExportExcel(DataTable dataTable, string heading = "", bool showSrNo = false, params string[] columnsToTake)
        {

            byte[] result = null;
            using (ExcelPackage package = new ExcelPackage())
            {
                ExcelWorksheet workSheet = package.Workbook.Worksheets.Add(String.Format("{0} Data", heading));
                int startRowFrom = String.IsNullOrEmpty(heading) ? 1 : 3;

                if (showSrNo)
                {
                    DataColumn dataColumn = dataTable.Columns.Add("#", typeof(int));
                    dataColumn.SetOrdinal(0);
                    int index = 1;
                    foreach (DataRow item in dataTable.Rows)
                    {
                        item[0] = index;
                        index++;
                    }
                }


                // add the content into the Excel file  
                workSheet.Cells["A" + startRowFrom].LoadFromDataTable(dataTable, true);

                // autofit width of cells with small content  
                int columnIndex = 1;
                foreach (DataColumn column in dataTable.Columns)
                {
                    int maxLength;
                    ExcelRange columnCells = workSheet.Cells[workSheet.Dimension.Start.Row, columnIndex, workSheet.Dimension.End.Row, columnIndex];
                    try
                    {
                        maxLength = columnCells.Max(cell => cell.Value.ToString().Count());
                    }
                    catch (Exception) //nishanc
                    {
                        maxLength = columnCells.Max(cell => (cell.Value +"").ToString().Length);
                    }

                    //workSheet.Column(columnIndex).AutoFit();
                    if (maxLength < 150)
                    {
                        //workSheet.Column(columnIndex).AutoFit();
                    }


                    columnIndex++;
                }

                // format header - bold, yellow on black  
                using (ExcelRange r = workSheet.Cells[startRowFrom, 1, startRowFrom, dataTable.Columns.Count])
                {
                    r.Style.Font.Color.SetColor(System.Drawing.Color.White);
                    r.Style.Font.Bold = true;
                    r.Style.Fill.PatternType = OfficeOpenXml.Style.ExcelFillStyle.Solid;
                    r.Style.Fill.BackgroundColor.SetColor(Color.Brown);
                }

                // format cells - add borders  
                using (ExcelRange r = workSheet.Cells[startRowFrom + 1, 1, startRowFrom + dataTable.Rows.Count, dataTable.Columns.Count])
                {
                    r.Style.Border.Top.Style = ExcelBorderStyle.Thin;
                    r.Style.Border.Bottom.Style = ExcelBorderStyle.Thin;
                    r.Style.Border.Left.Style = ExcelBorderStyle.Thin;
                    r.Style.Border.Right.Style = ExcelBorderStyle.Thin;

                    r.Style.Border.Top.Color.SetColor(System.Drawing.Color.Black);
                    r.Style.Border.Bottom.Color.SetColor(System.Drawing.Color.Black);
                    r.Style.Border.Left.Color.SetColor(System.Drawing.Color.Black);
                    r.Style.Border.Right.Color.SetColor(System.Drawing.Color.Black);
                }

                // removed ignored columns  
                for (int i = dataTable.Columns.Count - 1; i >= 0; i--)
                {
                    if (i == 0 && showSrNo)
                    {
                        continue;
                    }
                    if (!columnsToTake.Contains(dataTable.Columns[i].ColumnName))
                    {
                        workSheet.DeleteColumn(i + 1);
                    }
                }

                if (!String.IsNullOrEmpty(heading))
                {
                    workSheet.Cells["A1"].Value = heading;
                   // workSheet.Cells["A1"].Style.Font.Size = 20;

                    workSheet.InsertColumn(1, 1);
                    workSheet.InsertRow(1, 1);
                    workSheet.Column(1).Width = 10;
                }

                result = package.GetAsByteArray();
            }

            return result;
        }

        public static byte[] ExportExcel<T>(List<T> data, string Heading = "", bool showSlno = false, params string[] ColumnsToTake)
        {
            return ExportExcel(ListToDataTable<T>(data), Heading, showSlno, ColumnsToTake);
        }
    }

Ora aggiungi questo metodo nel punto in cui vuoi generare il file Excel, probabilmente per un metodo nel controller. È anche possibile passare i parametri per la stored procedure. Notare che il tipo di restituzione del metodo è FileContentResult. Qualunque query tu esegua, la cosa importante è devi avere i risultati in un List.

[HttpPost]
public async Task<FileContentResult> Create([Bind("Id,StartDate,EndDate")] GetReport getReport)
{
    DateTime startDate = getReport.StartDate;
    DateTime endDate = getReport.EndDate;

    // call the stored procedure and store dataset in a List.
    List<User> users = _context.Reports.FromSql("exec dbo.SP_GetEmpReport @start={0}, @end={1}", startDate, endDate).ToList();
    //set custome column names
    string[] columns = { "Name", "Address", "Zip", "Gender"};
    byte[] filecontent = ExcelExportHelper.ExportExcel(users, "Users", true, columns);
    // set file name.
    return File(filecontent, ExcelExportHelper.ExcelContentType, "Report.xlsx"); 
}

Maggiori dettagli possono essere trovati qui

0