Preenchendo um DataSet a partir de um DataAdapter

O ADO.NET DataSet é uma representação residente na memória de dados que fornece um modelo de programação relacional consistente independente da fonte de dados. O DataSet representa um conjunto completo de dados que inclui tabelas, restrições e relações entre as tabelas. Como o DataSet é independente da fonte de dados, um DataSet pode incluir dados locais para o aplicativo e dados de várias fontes de dados. A interação com fontes de dados existentes é controlada através do DataAdapter.

A SelectCommand propriedade do DataAdapter é um Command objeto que recupera dados da fonte de dados. O InsertCommand, UpdateCommande as DeleteCommand propriedades do são Command objetos que gerenciam atualizações dos dados na fonte de DataAdapter dados de acordo com as modificações feitas nos dados no DataSet. Essas propriedades são abordadas com mais detalhes em Atualizando fontes de dados com DataAdapters.

O Fill método do DataAdapter é usado para preencher a DataSet com os resultados do SelectCommandDataAdapter. Fill toma como seus argumentos a DataSet a ser preenchido e um DataTable objeto, ou o nome do DataTable a ser preenchido com as linhas retornadas do SelectCommand.

O Fill método usa o DataReader objeto implicitamente para retornar os nomes e tipos de coluna que são usados para criar as tabelas no DataSet, e os dados para preencher as linhas das tabelas no DataSet. As tabelas e colunas só são criadas se ainda não existirem; caso contrário, Fill usa o esquema existente DataSet . Os tipos de coluna são criados como tipos do .NET Framework de acordo com as tabelas em Mapeamentos de Tipo de Dados no ADO.NET. As chaves primárias não são criadas, a menos que existam na fonte de dados e DataAdapter.MissingSchemaAction esteja definido comoMissingSchemaAction ..AddWithKey Se Fill descobrir que existe uma chave primária para uma tabela, ela substituirá os dados na DataSet com dados da fonte de dados para linhas em que os valores da coluna de chave primária correspondem aos da linha retornada da fonte de dados. Se nenhuma chave primária for encontrada, os dados serão anexados às tabelas no DataSet. Fill usa quaisquer mapeamentos que possam existir quando você preenche o DataSet (consulte DataAdapter DataTable e DataColumn Mappings).

O exemplo de código a seguir cria uma instância de a SqlDataAdapter que usa a SqlConnection para o banco de dados do Microsoft SQL Server Northwind e preenche a DataTable em a DataSet com a lista de clientes. A instrução SQL e SqlConnection os argumentos passados para o SqlDataAdapter construtor são usados para criar a SelectCommand propriedade do SqlDataAdapter.

Exemplo

' Assumes that connection is a valid SqlConnection object.  
Dim queryString As String = _  
  "SELECT CustomerID, CompanyName FROM dbo.Customers"  
Dim adapter As SqlDataAdapter = New SqlDataAdapter( _  
  queryString, connection)  
  
Dim customers As DataSet = New DataSet  
adapter.Fill(customers, "Customers")  

// Assumes that connection is a valid SqlConnection object.  
string queryString =
  "SELECT CustomerID, CompanyName FROM dbo.Customers";  
SqlDataAdapter adapter = new SqlDataAdapter(queryString, connection);  
  
DataSet customers = new DataSet();  
adapter.Fill(customers, "Customers");  

Vários conjuntos de resultados

Se o DataAdapter encontrar vários conjuntos de resultados, ele criará várias tabelas no DataSet. As tabelas recebem um nome padrão incremental de TabelaN, começando com "Tabela" para Tabela0. Se um nome de tabela é passado como um argumento para o Fill método, as tabelas recebem um nome padrão incremental de TableNameN, começando com "TableName" para TableName0.

Preenchendo um DataSet a partir de vários DataAdapters

Qualquer número de DataAdapter objetos pode ser usado com um DataSetarquivo . Cada um DataAdapter pode ser usado para preencher um ou mais DataTable objetos e resolver atualizações de volta para a fonte de dados relevante. DataRelation e Constraint objetos podem ser adicionados localmente, o DataSet que permite relacionar dados de fontes de dados diferentes. Por exemplo, um DataSet pode conter dados de um banco de dados Microsoft SQL Server, um banco de dados IBM DB2 exposto por meio do OLE DB e uma fonte de dados que transmite XML. Um ou mais DataAdapter objetos podem manipular a comunicação com cada fonte de dados.

Exemplo

O exemplo de código a seguir preenche uma lista de clientes do Northwind banco de dados no Microsoft SQL Server e uma lista de pedidos do Northwind banco de dados armazenado no Microsoft Access 2000. As tabelas preenchidas estão relacionadas com um DataRelation, e a lista de clientes é então exibida com os pedidos desse cliente. Para obter mais informações sobre DataRelation objetos, consulte Adicionando DataRelations e Navegando DataRelations.

' Assumes that customerConnection is a valid SqlConnection object.  
' Assumes that orderConnection is a valid OleDbConnection object.  
Dim custAdapter As SqlDataAdapter = New SqlDataAdapter( _  
  "SELECT * FROM dbo.Customers", customerConnection)  
  
Dim ordAdapter As OleDbDataAdapter = New OleDbDataAdapter( _  
  "SELECT * FROM Orders", orderConnection)  
  
Dim customerOrders As DataSet = New DataSet()  
custAdapter.Fill(customerOrders, "Customers")  
ordAdapter.Fill(customerOrders, "Orders")  
  
Dim relation As DataRelation = _  
  customerOrders.Relations.Add("CustOrders", _  
  customerOrders.Tables("Customers").Columns("CustomerID"), _
  customerOrders.Tables("Orders").Columns("CustomerID"))  
  
Dim pRow, cRow As DataRow  
For Each pRow In customerOrders.Tables("Customers").Rows  
  Console.WriteLine(pRow("CustomerID").ToString())  
  
  For Each cRow In pRow.GetChildRows(relation)  
    Console.WriteLine(vbTab & cRow("OrderID").ToString())  
  Next  
Next  

// Assumes that customerConnection is a valid SqlConnection object.  
// Assumes that orderConnection is a valid OleDbConnection object.  
SqlDataAdapter custAdapter = new SqlDataAdapter(  
  "SELECT * FROM dbo.Customers", customerConnection);  
OleDbDataAdapter ordAdapter = new OleDbDataAdapter(  
  "SELECT * FROM Orders", orderConnection);  
  
DataSet customerOrders = new DataSet();  
  
custAdapter.Fill(customerOrders, "Customers");  
ordAdapter.Fill(customerOrders, "Orders");  
  
DataRelation relation = customerOrders.Relations.Add("CustOrders",  
  customerOrders.Tables["Customers"].Columns["CustomerID"],  
  customerOrders.Tables["Orders"].Columns["CustomerID"]);  
  
foreach (DataRow pRow in customerOrders.Tables["Customers"].Rows)  
{  
  Console.WriteLine(pRow["CustomerID"]);  
   foreach (DataRow cRow in pRow.GetChildRows(relation))  
    Console.WriteLine("\t" + cRow["OrderID"]);  
}  

Tipo decimal do SQL Server

Por padrão, o armazena DataSet dados usando tipos de dados do .NET Framework. Para a maioria dos aplicativos, eles fornecem uma representação conveniente das informações da fonte de dados. No entanto, essa representação pode causar um problema quando o tipo de dados na fonte de dados é um tipo de dados decimal ou numérico do SQL Server. O tipo de dados .NET Framework decimal permite um máximo de 28 dígitos significativos, enquanto o tipo de dados SQL Server decimal permite 38 dígitos significativos. Se determinar, SqlDataAdapter durante uma Fill operação, que a precisão de um campo do SQL Server decimal é maior que 28 caracteres, a linha atual não será adicionada ao DataTable. Em vez disso, o evento ocorre, o FillError que permite determinar se ocorrerá uma perda de precisão e responder adequadamente. Para obter mais informações sobre o FillError evento, consulte Manipulando eventos DataAdapter. Para obter o valor do SQL Server decimal , você também pode usar um SqlDataReader objeto e chamar o GetSqlDecimal método.

ADO.NET 2.0 introduziu suporte aprimorado para System.Data.SqlTypes o DataSet. Para obter mais informações, consulte SqlTypes e o DataSet.

Capítulos OLE DB

Conjuntos de linhas hierárquicos ou capítulos (tipo DBTYPE_HCHAPTEROLE DB, tipo adChapterADO) podem ser usados para preencher o conteúdo de um DataSetarquivo . Quando o OleDbDataAdapter encontra uma coluna capitulada durante uma Fill operação, a é criada para DataTable a coluna capitulada e essa tabela é preenchida com as colunas e linhas do capítulo. A tabela criada para a coluna capitulada é nomeada usando o nome da tabela pai e o nome da coluna capitulada no formato "ParentTableNameChapteredColumnName". Se já existir uma tabela que corresponda ao DataSet nome da coluna capitulada, a tabela atual será preenchida com os dados do capítulo. Se não houver nenhuma coluna em uma tabela existente que corresponda a uma coluna encontrada no capítulo, uma nova coluna será adicionada.

Antes que as tabelas no DataSet sejam preenchidas com os dados nas colunas capituladas, uma relação é criada entre as tabelas pai e filho do conjunto de linhas hierárquico adicionando uma coluna inteira à tabela pai e filha, definindo a coluna pai como incremento automático e criando uma DataRelation usando as colunas adicionadas de ambas as tabelas. A relação adicionada é nomeada usando os nomes da tabela pai e da coluna do capítulo no formato "ParentTableNameChapterColumnName".

Observe que a coluna relacionada só existe no DataSet. Preenchimentos subsequentes da fonte de dados podem fazer com que novas linhas sejam adicionadas às tabelas em vez de as alterações serem mescladas em linhas existentes.

Observe também que, se você usar a DataAdapter.Fill sobrecarga que leva um DataTable, apenas essa tabela será preenchida. Uma coluna inteira de incremento automático ainda será adicionada à tabela, mas nenhuma tabela filho será criada ou preenchida e nenhuma relação será criada.

O exemplo a seguir usa o MSDataShape Provider para gerar uma coluna de capítulo de pedidos para cada cliente em uma lista de clientes. A DataSet é então preenchido com os dados.

Using connection As OleDbConnection = New OleDbConnection( _  
  "Provider=MSDataShape;Data Provider=SQLOLEDB;" & _  
  "Data Source=(local);Integrated " & _  
  "Security=SSPI;Initial Catalog=northwind")  
  
Dim adapter As OleDbDataAdapter = New OleDbDataAdapter( _  
  "SHAPE {SELECT CustomerID, CompanyName FROM Customers} " & _  
  "APPEND ({SELECT CustomerID, OrderID FROM Orders} AS Orders " & _  
  "RELATE CustomerID TO CustomerID)", connection)  
  
Dim customers As DataSet = New DataSet()  
  
adapter.Fill(customers, "Customers")  
End Using  

using (OleDbConnection connection = new OleDbConnection("Provider=MSDataShape;Data Provider=SQLOLEDB;" +  
  "Data Source=(local);Integrated Security=SSPI;Initial Catalog=northwind"))  
{  
OleDbDataAdapter adapter = new OleDbDataAdapter("SHAPE {SELECT CustomerID, CompanyName FROM Customers} " +  
  "APPEND ({SELECT CustomerID, OrderID FROM Orders} AS Orders " +  
  "RELATE CustomerID TO CustomerID)", connection);  
  
DataSet customers = new DataSet();  
adapter.Fill(customers, "Customers");  
}  

Quando a Fill operação estiver concluída, a DataSet contém duas tabelas: Customers e CustomersOrders, onde CustomersOrders representa a coluna capitulada. Uma coluna adicional nomeada Orders é adicionada Customers à tabela e uma coluna adicional nomeada CustomersOrders é adicionada à CustomersOrders tabela. A Orders coluna na tabela é definida como incremento Customers automático. A DataRelation, CustomersOrders, é criada usando as colunas que foram adicionadas às tabelas com Customers como tabela pai. As tabelas a seguir mostram alguns resultados de exemplo.

TableName: Clientes

TableName: ClientesPedidos

Consulte também

• DataAdapters e DataReaders
• Mapeamentos de tipo de dados no ADO.NET
• Modificando dados com um DbDataAdapter
• Vários conjuntos de resultados ativos (MARS)
• Visão geral ADO.NET