Partilhar via

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, UpdateCommand e DeleteCommand propriedades do DataAdapter são Command objetos que gerenciam atualizações nos dados da fonte de dados de acordo com as modificações realizadas nos dados em 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 aceita como argumentos um DataSet a ser preenchido e um objeto DataTable, ou o nome do DataTable a ser preenchido com as linhas retornadas do SelectCommand.

Observação

Usar o DataAdapter para recuperar toda a tabela leva tempo, especialmente se houver muitas linhas na tabela. Isso ocorre porque acessar o banco de dados, localizar e processar os dados e, em seguida, transferir os dados para o cliente é demorado. Puxar toda a tabela para o cliente também bloqueia todas as linhas no servidor. Para melhorar o desempenho, você pode usar a WHERE cláusula para reduzir significativamente o número de linhas retornadas ao cliente. Você também pode reduzir a quantidade de dados retornados ao cliente listando apenas explicitamente as SELECT colunas necessárias na instrução. Outra boa solução é recuperar as linhas em lotes (como várias centenas de linhas de cada vez) e só recuperar o próximo lote quando o cliente terminar com o lote atual.

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 como MissingSchemaAction.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).

Observação

Se o SelectCommand retorna os resultados de um OUTER JOIN, o DataAdapter não define um PrimaryKey valor para o resultado DataTable. Você deve definir a PrimaryKey você mesmo para garantir que as linhas duplicadas sejam corrigidas corretamente. Para obter mais informações, consulte Definindo chaves primárias.

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 os argumentos SqlConnection passados para o construtor SqlDataAdapter são usados para criar a propriedade SelectCommand 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");

Observação

O código mostrado neste exemplo não abre e fecha explicitamente o Connectionarquivo . O Fill método abre implicitamente o Connection que o DataAdapter está usando se ele achar que a conexão ainda não está aberta. Se Fill abriu a conexão, ela também fecha a conexão quando Fill termina. Isso pode simplificar seu código quando você lida com uma única operação, como um Fill ou um Update. No entanto, se você estiver executando várias operações que exigem uma conexão aberta, poderá melhorar o desempenho do seu aplicativo chamando explicitamente o Open método do , executando as operações na fonte de Connectiondados e, em seguida, chamando o Close método do Connection. Você deve tentar manter as conexões com a fonte de dados abertas o mais brevemente possível para liberar recursos para uso por outros aplicativos cliente.

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 DataSet. Cada DataAdapter pode ser usado para preencher um ou mais objetos DataTable e aplicar as atualizações de volta à fonte de dados relevante. Objetos DataRelation e Constraint podem ser adicionados ao DataSet localmente, o que permite relacionar dados de fontes de dados distintas. 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, DataSet armazena 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 o SqlDataAdapter determinar durante uma operação de Fill que a precisão de um campo do SQL Server decimal é superior a 28 caracteres, a linha atual não será adicionada ao DataTable. Em vez disso, ocorre o evento FillError, que lhe 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 de OLE DB DBTYPE_HCHAPTER, tipo de ADO adChapter) podem ser usados para preencher o conteúdo de um DataSet. Quando o OleDbDataAdapter encontra uma coluna com capítulos durante uma operação Fill, é criada uma DataTable para a coluna com capítulos 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 é denominada 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 utilizar a DataAdapter.Fill sobrecarga que utiliza um DataTable, apenas essa tabela será preenchida. Uma coluna inteira de incremento automático ainda será adicionada à tabela, mas nenhuma tabela filha será criada ou preenchida, e nenhuma relação será estabelecida.

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 Customers é definida como automática para incremento. 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.

Nome da Tabela: Clientes

ID do Cliente Nome da Empresa Encomendas
ALFKI Alfreds Futterkiste 0
ANATR Ana Trujillo Emparedados y helados 1

TableName: Pedidos de Clientes

ID do Cliente ID do Pedido ClientesEncomendas
ALFKI 10643 0
ALFKI 10692 0
ANATR 10308 1
ANATR 10625 1

Ver também