fa1c0n3r's questions

Gostaria de gerar uma tabela nomeada em uma WITHcláusula que conterá esta progressão aritmética:

╔══════════╗
║ mynumber ║
╠══════════╣
║        0 ║
║       30 ║
║       60 ║
║       90 ║
║      120 ║
║      150 ║
║      180 ║
║      210 ║
╚══════════╝

...baseado na variável p_maxnumber(aqui p_maxnumber= 211 por exemplo).

O ideal seria em um formato como:

WITH sequenceTable AS
(SELECT mynumber
FROM ...),

Dentro da mesma WITHcláusula, gostaria de usar essa sequência em tabelas derivadas downstream para obter dados e, eventualmente, ser usada como um eixo de tempo para renderização de gráfico. Tenho a sensação de que existe uma maneira de fazer isso usando criar sequência? Apenas tentando descobrir uma maneira de criar isso ainda ...

Eu tenho uma série de tabelas definidas em um procedimento armazenado para eventualmente retornar ao aplicativo como este, culminando em uma tabela simples que contém valores distintos de uma tabela definida anteriormente e a contagem de quantas vezes esse valor distinto se repete. Por algum motivo, parece que não está funcionando...

...procedimento armazenado...

OPEN p_retcursor FOR
WITH r AS
(SELECT ...
FROM MYDATATABLE),

s  AS
(SELECT ...
FROM r
WHERE ...)
,

t AS
(SELECT ...
WHERE ... 
JOIN ...
ON ...
FROM s)

SELECT t.*, COUNT(*) as distinctABcount
FROM t
GROUP BY t.columnA, t.columnB

Como faço isso funcionar? Eu acho que tecnicamente a coluna A e a coluna B não são colunas de uma tabela, mas são colunas de t, então acho que a ordem de avaliação está um pouco confusa devido ao fato de que t não é uma tabela real ... A consulta falha em torno da contagem ( *) parte da coluna e pode estar falhando no GROUP BY.

Obrigado.

Atualização 1: Tenho uma teoria de que, se eu agrupar todas as tabelas nomeadas em subconsultas dentro da cláusula from, isso funcionará ... mas isso não parece ser uma solução que produzirá código legível, considerando que esse procedimento armazenado tem centenas de linhas ...

Atualização 2:
a teoria estava errada, a tabela derivada não era o problema, mas, conforme apontado pela resposta, você não pode solicitar mais colunas do que definiu na cláusula group by. Eu consertei corrigindo a seção final da consulta como sugerido:

select t.columnA, t.columnB, COUNT(*) as distinctABcount
FROM t
GROUP BY t.columnA, t.columnB

que roda corretamente.

Minha pergunta é, tenho uma tabela que contém uma coluna chamada myDateColumn (por exemplo) que é do tipo data:

Posso confirmar que desc myTablecontém esta linha:

myDateColumn  NOT NULL     DATE   

Porém, quando tento selecionar todos os dados que estão entre determinadas datas, por exemplo:

select * from myTable 
where myDateColumn 
between to_date('13-FEB-11', 'DD-MON-YY') AND TO_DATE('15-FEB-11', 'DD-MON-YY');

Recebo resultados nulos, não importa o que aconteça, embora tenha certeza de que alguns dados existem dentro desse intervalo de datas específico.

A correção que descobri foi converter explicitamente myDateColumn em uma data:

select myDateColumn from myTable 
where to_date(myDateColumn) 
between to_date('13-FEB-11', 'DD-MON-YY') AND TO_DATE('15-FEB-11', 'DD-MON-YY');

que retorna os resultados corretos, mas já é um tipo de data! Por que preciso converter explicitamente uma coluna de data em data antes de fazer a betweencomparação lógica?

O motivo de eu perguntar é porque esse select/ where fará parte de um procedimento armazenado selecionando dados dentro de um intervalo de data específico para ser executado em uma grande tabela particionada por data, com mais de dez milhões de linhas, e se eu puder evitar converter explicitamente cada myDateColumn de cada linha, então eu poderia economizar algum tempo de consulta, em teoria.

Ou existe uma maneira mais correta de executar essa comparação para selecionar dados em um intervalo de datas?

Obrigada.

Atualização: Leigh sugeriu na resposta diagnosticar a tabela por algo inconsistente com sua consulta. O resultado de sua consulta foi:

myDateColumn    TO_DATE(myDateColumn)   TO_CHAR(myDateColumn,'DD-MON-YYHH.MI.SSPM') TO_CHAR(myDateColumn,'YYYY')  
14-Feb-11   14-Feb-11   14-FEB-11 12.00.00 AM   0011
14-Feb-11   14-Feb-11   14-FEB-11 12.00.00 AM   0011
14-Feb-11   14-Feb-11   14-FEB-11 12.00.00 AM   0011
14-Feb-11   14-Feb-11   14-FEB-11 12.00.00 AM   0011
14-Feb-11   14-Feb-11   14-FEB-11 12.00.00 AM   0011

Indicando que o motivo da betweencláusula não estar funcionando, é porque nenhum dos dados cairia no intervalo de consulta, já que o ano era 0011, durante o Império Romano :)

Obrigado rapazes.

Qual é a sintaxe de um procedimento armazenado que gera um refcursor, um varchar2 e um número?

Gostaria de exibir todos os três no resultado, com o objetivo de exibir contagem, e uma mensagem que indica uma consulta bem-sucedida além da saída sys_refcursor, mas não consigo encontrar um bom exemplo disso.

Meu código C# atual é assim:

using Oracle.DataAccess.Client; 
//...

OracleCommand myCmd = new OracleCommand();
myCmd.Connection = myConnection;
myCmd.CommandText = "mypackage.myprocedure"
myCmd.CommandType = CommandType.StoredProcedure;
OracleParameter param0 = myCmd.Parameters.Add("myinput", OracleDbType.Varchar2, myinput, ParameterDirection.Input);
OracleParameter param1 = myCmd.Parameters.Add("myretcursor", OracleDbType.RefCursor, ParameterDirection.Output);

myConnection.Open();
OracleDataReader resultReader = myCmd.ExecuteReader();
mydatatable.Load(resultReader, LoadOption.OverwriteChanges);

e o procedimento armazenado do Oracle se parece com isto:

    PROCEDURE myprocedure (myinput IN Varchar2, myretcursor OUT sys_refcursor)

    IS

    BEGIN
    OPEN myretcursor FOR
    SELECT * FROM MYTABLE

    END myprocedure

Acho que quero adicionar param2, param3 ao c# como parâmetros de saída adicionais e, de alguma forma, também produzi-los no procedimento armazenado? Eu não tinha certeza de como fazer isso e continuava encontrando erros. Idealmente, eu passaria, por exemplo, a contagem de seleção (*) como saída para o aplicativo c#, bem como uma mensagem de string varchar2 como 'Consulta bem-sucedida'.

Obrigada.

ATUALIZAÇÃO: A solução de Vincent funciona abaixo... em relação ao código C# por trás, a resposta ao link que ele forneceu recomenda colocar o leitor = executereader em um USING( ) para carregar a tabela e fechar o leitor antes de carregar as outras variáveis.

https://stackoverflow.com/q/6882690/613799

Dependendo do tamanho da string do oracle, o código c# de chamada pode precisar especificar o tamanho do varchar2 na definição do parâmetro de saída para a mensagem da string. Por fim, o link a seguir foi útil para converter a contagem de OracleDecimal para C# int:

https://stackoverflow.com/q/3026036/613799

Eu tenho uma variável em um procedimento armazenado Oracle do DATEtipo (da interface do usuário), e outra do TIMESTAMPtipo (banco de dados é mais preciso do que o usuário digitaria no código que está executando o procedimento armazenado).

Eu gostaria de fazer algo assim: (pseudo código)

select * from MYDATABASE where inputDate = extract(date from myDatabaseTimeStamp);

mas recebo um erro de compilação quando tento isso. Alguma idéia de qual é uma boa solução de código real para isso?

Não estamos acostumados a usar Oracle, mas temos um grande banco de dados onde uma consulta não exclusiva como

SELECT * FROM employees where department = 'HR'  

está funcionando, os resultados aparecem sem problemas.

Mas quando eu faço

SELECT * FROM employees where employeeID = '3HVtxO-F3004728F87EF61E'  

a consulta do banco de dados oracle está suspensa (espero que um registro volte e tenho certeza de que existe porque copiei e colei o employeeID de outra consulta).

Para as colunas, a única diferença entre as duas é:

department is VARCHAR2(25)  NULL
employeeID is VARCHAR2(50)  NULL

Além disso, o departamento teria muitas correspondências, enquanto o ID do funcionário provavelmente teria 1 (não consigo ver que seja particularmente definido para ser exclusivo na definição da tabela).

Outras características da mesa:

• na verdade não é uma tabela de funcionários, ela tem dados relacionados ao trabalho, então eu a renomeei aqui...
• contém mais de um milhão de linhas e algumas dezenas de colunas
• um pouco de um banco de dados antigo, não tenho certeza de quem o projetou no trabalho há muito tempo, poderia ter problemas de integridade / indexação do banco de dados?
• uma seleção regular * de funcionários sem cláusula where também não funcionaria porque congela em torno da marca de meio milhão de linhas encontradas.

Alguma ideia de por que isso pode estar acontecendo? Devo projetar melhor minha consulta? Como você recomendaria diagnosticar algum problema relacionado a problemas com o próprio banco de dados? Tentando entender esse banco de dados oracle, mas um pouco estranho de se acostumar, pois uma consulta simples que deve retornar um item está suspensa. Obrigada.

Atualização 1: Respondendo aos comentários, não há indexação para esta coluna. Felizmente, esta é uma tabela desatualizada que não será usada, com uma nova versão sendo feita que terá colunas indexadas, então acho que esse foi um problema.

Em relação ao plano para a segunda consulta, fica assim:

Plan hash value: 123724717

------------------------------------------------------------------------------------------------
| Id  | Operation           | Name     | Rows  | Bytes | Cost (%CPU)| Time     | Pstart| Pstop |
------------------------------------------------------------------------------------------------
|   0 | SELECT STATEMENT    |          |    12 |  4416 |  2376K  (1)| 07:55:19 |       |       |
|   1 |  PARTITION RANGE ALL|          |    12 |  4416 |  2376K  (1)| 07:55:19 |     1 |    14 |
|*  2 |   TABLE ACCESS FULL | [Employee|    12 |  4416 |  2376K  (1)| 07:55:19 |     1 |    14 |
------------------------------------------------------------------------------------------------

Query Block Name / Object Alias (identified by operation id):
-------------------------------------------------------------

   1 - SEL$1
   2 - SEL$1 / Employees@SEL$1

Predicate Information (identified by operation id):
---------------------------------------------------

   2 - filter("EmployeeID"='3R5MMN-0F9345L9IK8A349A043')

Column Projection Information (identified by operation id):
-----------------------------------------------------------
-- The list of all the columns follows.

Meu palpite é que esta é apenas uma tabela realmente muito bem projetada e não projetada para ficar tão grande, ou para alguém realmente usar muito :) Para fins práticos, passarei para encarnações mais recentes desta tabela que terão indexação e espero que isso resolva.

Tenho certeza de que existem algumas maneiras fáceis de fazer isso ... Eu tenho uma tabela simples e plana do Oracle com cerca de 13 terabytes de tamanho devido a um grande número de linhas acumuladas ao longo dos anos. Preciso fazer uma pesquisa nele (pode estar procurando correspondências em vários campos) e gostaria de retornar os registros mais relevantes em uma lista, como os 50 principais ou os 100 principais, nos quais posso clicar para obter mais detail (então consultará especificamente um campo nesse registro específico).

Qual biblioteca ou pacote .net ou Java você recomendaria para esse tipo de pesquisa no Oracle? Alguma chance de haver um exemplo de aplicativo de código aberto ou exemplo como esse por aí que faz exatamente isso? Espero encontrar algo que me permita priorizar correspondências em determinadas colunas primeiro e encontre correspondências rapidamente, apesar do tamanho grande da tabela, e possa ser facilmente integrado à segunda parte do requisito, que é uma consulta regular baseada em um "thread" ao qual esse registro pertence.

Obrigada.

um tempo atrás eu fiz uma pergunta sobre como tornar o diálogo de início e envio mais flexível para que ele possa ser incorporado em um procedimento que leva os parâmetros to, from, como variáveis ​​sysname.

Service Broker Procedimento que será usado por vários iniciadores para iniciar a conversa de diálogo.. como passar um parâmetro para ele

no entanto, como Rusanu mencionou na resposta, essa mesma técnica não pode ser usada para a cláusula From do Receive.

Na verdade vai funcionar. A maioria dos verbos SSB aceita parâmetros para seus argumentos (exceto o nome da fila para RECEIVE, é claro). Os parâmetros são do tipo sysname ...

na verdade o lado de envio está feito e agora estou tentando flexibilizar o RECEIVE da mesma forma, algo como:

CREATE PROCEDURE QueueReceive
  @myTargetQueue SYSNAME
  @cg UNIQUEIDENTIFIER OUTPUT
  @ch UNIQUEIDENTIFIER OUTPUT
  @msg XML OUTPUT
as
    BEGIN TRANSACTION;
    WAITFOR
            ( RECEIVE TOP(1)
                @cg = conversation_group_id,
                @msg = cast(message_body as XML),
                @ch= conversation_handle  
              FROM @myTargetQueue
            ), TIMEOUT 3000;
    COMMIT
...

Parece que variáveis ​​do tipo sysname não podem ser usadas na cláusula from do RECEIVE? Se eu tivesse que fazer isso em SQL dinâmico, como retornaria todas as variáveis, conversation_group_id, conversation_handle, etc. da execução do sql dinâmico de uma função de recebimento? existe uma técnica de melhor desempenho para realizar a mesma coisa?

Obrigada.

CORREÇÃO/Atualização ATÉ AGORA: Estou criando um monte de cláusulas IF dependendo de qual é o parâmetro passado, ele apenas executará uma instrução de recebimento inteira diferente. Não é eficiente porque tenho que alterar o código do procedimento sempre que adiciono uma nova QUEUE, mas acho que serve por enquanto ...

Fiz uma pergunta sobre a implementação de grupos de conversação em uma configuração do SQL Service Broker que possui vários serviços de usuário se comunicando com o serviço do servidor (processando solicitações de dados xml a serem enviadas para um serviço da Web externo). Mas, como os grupos de conversação não garantem a ordem no processamento, você acha que há algo de errado em usar o mesmo identificador de conversa para todas as solicitações que vão para a mesma fila de destino (garantindo a ordem em que foram enviadas, independentemente da origem) ?

para o segundo plano: como você implementaria grupos de conversação/bloqueio para vários usuários de uma fila do Service Broker?

Como foi mencionado por Rusanu na resposta,

E não se esqueça que a única construção que garante a ordem no SSB é uma conversa. Portanto, se os usuários precisarem enviar lances para A na conversa 1, seguidos de lances para B na conversa 2, não há garantia de que o lance para A será processado depois que o lance para B for processado. A única garantia é que se o usuário 1 enviar dois lances para A, eles serão processados ​​na ordem enviada.

Além disso, se dois usuários diferentes enviarem lances para o produto A, não há garantia da ordem de processamento desses lances. No entanto, se os lances do produto A terminarem no mesmo CG, existe a garantia de que apenas um 'processador thread' verá o lance do usuário 1 e o lance do usuário 2, mas tenha cuidado porque não há garantia de que os lances são apresentados no conjunto de resultados RECEIVE na ordem em que foram recebidos. A RECEIVE apenas garante que:

* all messages in the result set are from the same CG
* the messages belonging to a conversation are in order

mas a ordem das conversas no resultado é basicamente aleatória (é orientada pela ordem do identificador de conversa, um GUID).

Como em um leilão real, eu gostaria que os itens da fila fossem processados ​​na ordem em que estão chegando na fila para o usuário A, usuário B e usuário C enviando um "lance" para o mesmo produto. Estou pensando em implementar tudo isso usando os mesmos identificadores de conversa para todas as conversas no mesmo produto.

O que acho que vou tentar até agora:

O mecanismo será o aplicativo do servidor enviar um iniciador de conversa (inicialização) para N conversas para um User_0 (onde N é o número de "canais de conversa multiplexados" que teremos) - armazenamos os identificadores de conversa em uma tabela como esta :

CREATE TABLE ConversationChannelStatus
(ConversationChannel_pk numeric Primary Key, ConversationHandle UNIQUEIDENTIFIER)

USER_A, ao enviar "lances", enviará uma mensagem do User_A Service para o serviço de destino usando os handles de conversa que estão salvos na Tabela ConversationChannelStatus (Indexada por uma chave primária numérica simples, o "ConversationChannels").

É problemático armazenar identificadores de conversa em uma tabela e, em seguida, fazer com que vários serviços do iniciador continuem usando os mesmos identificadores de conversa enquanto enviam mensagens para a fila de destino?

Obrigada.

Atualização: Desculpe, confundi-me com estas palavras, ID da conversa, identificador da conversa. O mesmo identificador de conversa definitivamente não pode ser usado porque é diferente para iniciador e destino. Acho que estou me referindo a tentar usar o mesmo ID de conversa de vários iniciadores para o mesmo destino para tentar manter a ordem na fila de processamento de mensagens provenientes de vários serviços.

Atualização 2: Ainda trabalhando nisso, mas acho que a solução será assim, envolvendo ambos os identificadores de conversação e o conversationgroupid.

1. Comece inicializando a conversa N versus o usuário 0 e armazene o ID do grupo de conversação, bem como o identificador de conversa, ambos na tabela de configurações do canal.
2. Quando um serviço UserA, UserB, UserC deseja ingressar, o aplicativo do servidor iniciará as N conversas com cada um dos serviços do usuário, usando os identificadores de conversa que armazenamos anteriormente na tabela de configurações do canal.
3. Em seguida, os serviços do usuário (os alvos dessa mensagem) receberão essa mensagem e responderão usando os conversationgroupIds da tabela de configurações do canal somente quando o serviço do usuário tiver um "lance" para enviar. Assim, fornecendo uma maneira fácil para o serviço do usuário saber qual ID do grupo de conversação relacionado usar, mantendo a ordem de conversa desejada no servidorAPP Serviço fila de processamento de mensagens dos usuários A, B, C (uma vez que está respondendo a uma conversa específica iniciada por o serviço serverapp). Eu espero que dê certo!

O formato padrão para iniciar um diálogo é assim:

Declare @dialog_handle UNIQUEIDENTIFIER
BEGIN DIALOG CONVERSATION @dialog_handle
   FROM SERVICE initiator_1
   TO SERVICE 'target_1'
   ON CONTRACT MyContract ;

Mas eu gostaria de criar um procedimento genérico flexível que possa enviar uma conversa específica de qualquer um de vários serviços de iniciador (digamos que eu tenha 10 serviços de iniciador em potencial que usariam o mesmo procedimento armazenado).

Create Procedure SendJoinRequest (@initiatorServiceName varchar)
AS
   Declare @dialog_handle UNIQUEIDENTIFIER
BEGIN DIALOG CONVERSATION @dialog_handle
   FROM SERVICE @initiatorServiceName
   TO SERVICE 'target_1'
   ON CONTRACT MyContract ;

Acho que isso não vai funcionar porque o identificador do serviço em

FROM SERVICE @initiatorServiceName 

na verdade não pode ser uma string e deve ser o nome real do serviço... Existe uma maneira fácil de passar isso como um argumento? ou eu tenho que aninhar tudo isso em uma execução desagradável de uma string concatenada?

@String = blahblah + blah blah + escapecharacters + blah
execute(@String)

Obrigado pela ajuda

Como você implementa grupos de conversação para vários usuários usando sua própria instância dos aplicativos de usuário, mas enviando mensagens relacionadas à fila do agente de serviços? Algum bom exemplo desse tipo de implementação? Eu tinha imaginado que eu mesmo poderia definir o ID do grupo de conversação, garantindo que certos grupos de mensagens de vários usuários sejam relacionados, mas parece que esse valor vai ser gerado automaticamente como um UNIQUEIDENTIFIERS... Será que essa é mesmo a melhor maneira fazer isso?

Eu gostaria de ter certeza de capturar e bloquear mensagens relacionadas onde dois usuários "no mesmo time", por exemplo, estão fazendo lances no mesmo item juntos, para que a lógica do aplicativo do servidor possa processar adequadamente essas mensagens relacionadas juntas (basicamente apenas a primeira será aceito e o segundo será rejeitado até que a visualização do usuário possa ser atualizada para que ele saiba que o outro usuário já alterou o lance).

a direção do fluxo é dos usuários A, B, C enviando mensagens xml para a fila e, em seguida, um serviço de desenfileiramento que envia o xml para um serviço da Web externo. As mensagens que estamos enviando são mensagens xml estruturadas que modificarão pedidos em diferentes itens no serviço da Web externo após o desenfileiramento.

Obrigada!

Estou projetando um sistema para vários usuários enfileirarem suas solicitações para um serviço da Web que recebe solicitações como criação de novas entradas, alteração de entradas, solicitação de dados. Muitas das chamadas de serviço da Web que usaremos usam dados hierárquicos como parâmetros (hierarquias projetadas para corresponder a estruturas de objeto c#), enquanto outras, como uma solicitação para a lista de tipos de entrada permitidos, não requerem parâmetros. A fila é necessária porque o serviço da web tem um requisito de limitação de 5 segundos ou mais, e apenas um login de serviço da web será usado por vários usuários.

xml Os dados retornados do serviço da Web eventualmente voltarão, serão analisados ​​por nosso próprio aplicativo de servidor e inseridos em uma tabela de resposta de algum tipo para que o aplicativo do usuário possa saber que a solicitação foi recebida e também obter os dados retornados.

imagem básica é

aplicativo de usuário (vários usuários) --> fila de solicitação de serviço <--> aplicativo de servidor <--> serviço da web

e as respostas voltando da mesma forma

aplicativo do usuário (vários usuários) <-- fila de resposta do serviço <--> aplicativo do servidor <--> serviço da web

Estou criando o aplicativo de usuário e o aplicativo de servidor sozinho, e apenas tentando entender como projetar a fila de solicitação de serviço e as filas de resposta que usarão o sql server e tentando descobrir quantas tabelas essas filas terão desde solicitações e respostas vêm em forma hierárquica (diferentes tipos de hierarquia também são retornados, dependendo da solicitação), e ambas não hierárquicas.

Objetos como esses são especificados pela API de serviço da web externo. Os usuários estão enviando diferentes tipos de solicitações em diferentes formas relacionadas dessa estrutura de objeto, que serão armazenadas no sistema/filas de filas e, em seguida, coletadas pelo aplicativo do servidor para desenfileiramento para atender a um requisito de limitação para o serviço da web. O aplicativo do servidor também pode cancelar solicitações irrelevantes, como se muito tempo tiver passado e ele suspeitar de uma solicitação com falha ou não relevante, ou se o aplicativo do usuário não estiver sincronizado com o fluxo de dados do serviço da web.

Alguém tem algum exemplo simples de filas de vários usuários do servidor SQL usadas para essa finalidade? Existe algum bom livro sobre este tema? ou tutorial na web, talvez? parece necessário para limitar vários usuários de qualquer serviço da web ...

Estou tentando aprender como transformar XML em tabelas SQL hierárquicas.

Encontrei um trecho de código antigo de um fórum da Microsoft que é basicamente o que estou tentando fazer, mas gostaria de saber se alguém poderia ajudar a descobrir o que está acontecendo linha por linha neste código, principalmente depois que o xml foi carregado no @XML

--I understand this part, just making the tables  

DECLARE @Books TABLE (BookID int identity(1,1),BookTitle varchar(50),BookLanguage varchar(20),BookPrice decimal(18,2))  
DECLARE @Topics TABLE (TopicID int identity(1,1),BookID int,TopicTitile varchar(50),Page int)  

--I understand this part, defining the @xml variable to be the xml below.. just a usual xml...


DECLARE @xml XML  
SET @xml = '  
<bookstore>  
    <name>My Bookstore</name><br/>  
    <location>New York</location><br/>  
    <book>  
        <title lang=&quot;eng&quot;>Harry Potter</title>  
        <price>29.99</price>  
        <tableOfContents>  
            <topic>  
                <title>Harry Potter Topic 1</title>  
                <page>2</page>  
            </topic>  
            <topic>  
                <title>Harry Potter Topic 2</title>
                <page>5</page>
            </topic>
        </tableOfContents>
    </book>
    <book>
        <title lang=&quot;eng&quot;>Learning XML</title>
        <price>39.95</price>
        <tableOfContents>
            <topic>
                <title>Learning XML Topic 1</title>
                <page>1</page>
            </topic>
            <topic>
                <title>Learning XML Topic 2</title>
                <page>2</page>
            </topic>
        </tableOfContents>
    </book>
</bookstore>'



--what is going on below here?  I am familiar with inserting data into tables,  
--but what kind of insert is this where you are selecting some things and then doing a  
--from @xml.nodes also, what is that T(c) at the end?  and do we always have to put    
--a [1] after each xml element to denote we are referring to the first one we encounter?  


INSERT INTO @Books  
SELECT T.c.value('title[1]','varchar(50)') AS 'BookTitle',  
    T.c.value('(title/@lang)[1]','varchar(20)') AS 'BookLanguage',  
    T.c.value('price[1]','decimal(18,2)') AS 'BookPrice'  
FROM @xml.nodes('/bookstore/book') T(c)  


--what is going on here as well?  what is n(x) ? 
--could you explain this line by line-ish as well? I ran this on  
--SQL Server Management Studio and noticed that both of the 'topic titles' for each  
--book got inserted.  Where in the code did those get put into the table?

INSERT INTO @Topics  
SELECT b.BookID,n.x.value('title[1]','varchar(50)') AS 'TopicTitile',  
    n.x.value('page[1]','int') AS 'TopicPage'  
FROM @Books b   
cross apply @xml.nodes('/bookstore/book/tableOfContents/topic[../../title=sql:column("b.BookTitle")]') n(x)  


--below here is just regular sql selects so this makes sense.  

SELECT BookID,BookTitle,BookLanguage,BookPrice FROM @Books  
SELECT TopicID,BookID,TopicTitile,Page FROM @Topics  

O fórum ao qual eu estava me referindo e tentando aprender com o post antigo é:

http://social.msdn.microsoft.com/Forums/en/sqlxml/thread/7216ccc9-c1d7-418d-95a2-ec3a96de2c27

Estou criando um banco de dados para um sistema do tipo contabilidade/vendas semelhante a um banco de dados de vendas de carros e gostaria de fazer algumas transações para as seguintes ações do mundo real:

1. o vendedor cria um novo produto enviado ao chão (itemmpk, marca do carro, ano, preço).
2. vendedor muda de preço.  
3. vendedor cria entrada de venda para produto vendido (salespk, itemforeignkey, preço vendido, vendedor).  
4. vendedor cancela item para produto removido.  

5. vendedor cancela venda para venda cancelada.

      Os exemplos que encontrei online são muito genéricos, como "isto é uma transação", gostaria de algo parecido com o que estou tentando fazer para entender.

Alguém tem alguns bons exemplos de SQL semelhantes ou relacionados que eu possa ver para projetá-los? As pessoas usam transações para bancos de dados de vendas? Ou se você já fez esse tipo de transação sql antes, poderia fazer um esboço de como isso poderia ser feito?

Meu tópico (fechado como não é uma pergunta real) até agora no estouro de pilha: Precisa de procedimentos de transação SQL de exemplo para rastreamento de vendas ou banco de dados financeiro

Última atualização, o usuário enviará novas entradas/alterações/e cancelamentos do aplicativo ac#. Dados de aplicativos:

• Produtos em exibição (este é o nó pai que possui 3 nós filhos)

• Vendas (nó filho de Produtos em exibição)

• Recursos personalizados do produto (nó filho de produtos em exibição)

• Preço do produto / status atual (nó filho de Produtos em exibição)

O aplicativo C # empacotará esses dados no formato XML e, em seguida, executará alguns procedimentos armazenados SQL com transações que mantêm juntas as conversões xml para tabela nas tabelas SQL projetadas com a mesma estrutura de nó pai/filho usando algo como o que é descrito pelas respostas a isso relacionado pergunta sobre Stack Overflow: https://stackoverflow.com/q/2756773/613799

Eu gostaria que houvesse um livro sobre como projetar bancos de dados de vendas multiusuário e as transações de procedimento armazenado que serão usadas pelos aplicativos de usuário relacionados a partir do zero app->xml->database. Por favor, deixe-me saber se você sabe de um bom, ou um capítulo de um livro.