Vou criar aqui um exemplo bem simples para mostrar como funcionam as operações básicas em banco de dados, conhecidas através do acrônimo CRUD (Create, Retrieve, Update e Delete), com o RestfulX.

O projeto é simples (outro daqueles que todo mundo já fez na vida): um cadastro de eventos e participantes destes eventos. Este exemplo irá evoluindo conforme for aumentando a complexidade dos artigos.

Aqui está a definição do modelo inicial do nosso projeto:

participante:
  - nome: string
  - email: string
  - data_registro: date

evento:
  - nome: string
  - local: string
  - data: date
  - ativo: boolean

Configuramos o arquivo db/seeds.yml para criar alguns registros na tabela de participantes e eventos:

Evento.create(:nome => "Congresso de TI", :local => "Auditorio XYZ", :data => '2010-01-01', :ativo => true)

Participante.create(:nome => "Elvis Fernandes", :email => "elvis@exemplo.com", :data_registro => '2009-12-01')
Participante.create(:nome => "Jose da Silva", :email => "jose@exemplo.com", :data_registro => '2009-10-12' )
Participante.create(:nome => "Maria da Silva", :email => "maria@exemplo.com", :data_registro => '2009-10-12' )

Agora criamos os models, as migrations e atualizamos o banco de dados (já falei sobre esses comandos antes, mas não custa nada repetir):

ruby script/generate rx_yaml_scaffold
rake db:refresh
rake db:seed

Aqui está o código da tela que vamos usar para listar os participantes (coloquei este arquivo com o nome CRUDParticipantes dentro da pasta app/flex/nomedoprojeto/views. O nome do arquivo não tem nenhum motivo especial não. É pura falta de criatividade mesmo.):

<?xml version="1.0" encoding="utf-8"?>
<mx:Canvas xmlns:mx="http://www.adobe.com/2006/mxml" width="400" height="334">
	<mx:Script>
		<![CDATA[
			import org.restfulx.utils.TypedArray;
			import mx.controls.Alert;
			import mx.rpc.events.FaultEvent;
			import restfulxelvisetibr.models.Participante;
			import org.restfulx.Rx;

			private function onSuccessResultHandler(models:TypedArray):void
			{
				lblStatus.text = "Models carregados com sucesso.";
			}

			private function onFailureResultHandler(event:FaultEvent):void
			{
				Alert.show("Ocorreu um erro ao listar os participantes", "Erro");
			}
		]]>
	</mx:Script>

	<mx:Label x="10" y="10" text="Lista de participantes cadastrados"/>

	<mx:DataGrid id="dgParticipantes"
		dataProvider="{Rx.models.cached(Participante)}"
		x="10" y="36" width="380" height="254">

		<mx:columns>
			<mx:DataGridColumn headerText="Nome" dataField="nome"/>
			<mx:DataGridColumn headerText="E-mail" dataField="email"/>
			<mx:DataGridColumn headerText="Data de registro" dataField="dataRegistro"/>
		</mx:columns>
	</mx:DataGrid>

	<mx:Label id="lblStatus"
		x="10" y="306" />

	<mx:Button id="btnCarregar"
		label="Carregar dados"
		click="{Rx.models.index(Participante, onSuccessResultHandler, onFailureResultHandler)}"
		right="10" bottom="10"/>

</mx:Canvas>

Como o foco aqui é o RestfulX (estou assumindo que você compreende tudo relacionado a interface, funções, etc no código acima), vou falar apenas sobre o dataProvider do DataGrid chamado de dgParticipantes.

Veja o código executado quando o botão btnCarregar for clicado (linha 41): Rx.models.index(Participante, onSuccessResultHandler, onFailureResultHandler). Esta função é a responsável pela operação de obter os dados do servidor (Retrieve). Ela envia uma solicitação via GET para o servidor e espera o retorno. Quando o RestfulX recebe os dados retornados do servidor, ele vai transformar o XML recebido em objetos do sistema, no nosso caso, em instâncias da classe Participante. A partir deste momento, os dados carregados ficam armazenados na memória do computador do cliente (no cache do RestfulX)

Uma vez que os dados foram carregados para o cache, basta usar a função Rx.models.cached(Participante) (linha 26) para definir o dataProvider do DataGrid. Essa função vai pegar todos os objetos do tipo Participante armazenados no cache e exibí-los no DataGrid sem fazer nenhuma consulta ao servidor. O retorno dessa função é do tipo ModelsCollection, que estende a classe ArrayCollection.

Cada registro da tabela participantes será exibido em uma linha do DataGrid, e basta informar na propriedade dataField de cada coluna o nome do campo que será mostrado naquela coluna.

A função Rx.models.index tem apenas um parâmetro obrigatório, que indica qual model deve ser carregado para o cache (no exemplo eu coloquei o model Participante). O segundo parâmetro pode ser a função que será executada quando os models forem listados corretamente ou um array com qualquer dos parâmetros aceitos pela função index. O terceiro parâmetro é a função que será executada caso ocorra algum problema quando a aplicação tentar acessar o servidor.

O array que é o segundo parâmetro da função index pode causar algumas confusões quando começamos a trabalhar com o RestfulX, mas logo vemos a utilidade disso: por exemplo, se você quiser informar um valor para o último parâmetro da função, o parâmetro append, você não precisa informar o valor null para todos os outros parâmetros que antecedem o parâmetro desejado. Basta informá-lo no array do segundo parâmetro.

Dessa forma, a função index também poderia ser invocada da seguinte forma:

Rx.models.index( Participante, { onSuccess: onSuccessResultHandler, onFailure: onFailureResultHandler } )

Quando você quiser simplesmente carregar os dados no cache (sem fazer nenhuma verificação se ocorreu um erro ou ser avisado quando o carregamento dos dados for concluído), você também pode invocar a função index informando apenas o primeiro parâmetro. A utilização dessas funções é importante para dar um feedback para o usuário acerca do que está acontecendo no sistema.

Em breve vou publicar outros artigos falando das demais operações básicas em bancos de dados com o RestfulX, e nestas oportunidades falarei um pouco mais sobre os outros parâmetros das funções que mostrei aqui.

Edit @ 22/dez/09
Veja a segunda parte deste artigo: CRUD com o RestfulX: Parte 2/2 – Create, Update e Delete