{-# OPTIONS_HADDOCK hide #-}
-- Stream Types:    https://msdn.microsoft.com/en-us/library/dd303435.aspx
-- Data Types:      https://msdn.microsoft.com/en-us/library/dd305325.aspx
-- Data Stream:     https://msdn.microsoft.com/en-us/library/dd340794.aspx
-- Server Messages: https://msdn.microsoft.com/en-us/library/dd357167.aspx


module Database.Tds.Message.Server ( TokenStreams (..)
                                   , TokenStream (..)
                                   
                                   , AltMetaData (..)
                                   , AltRowData (..)
                                   
                                   , ColProperty (..)
                                   , CPColNum (..)
                                   , CPTableNum (..)
                                   , CPStatus (..)
                                   , CPColName (..)

                                   , ColMetaData (..)
                                   , MetaColumnData (..)
                                   , MCDUserType (..)
                                   , MCDFlags (..)
                                   , MCDTableName (..)
                                   , MCDColName (..)

                                   , Done (..)
                                   , DoneStatus (..)
                                   , DoneCurCmd (..)
                                   , DoneRowCount (..)

                                   , ECType (..)
                                   , ECNewValue (..)
                                   , ECOldValue (..)

                                   , Info (..)
                                   , InfoNumber (..)
                                   , InfoState (..)
                                   , InfoClass (..)
                                   , InfoMsgText (..)
                                   , InfoServerName (..)
                                   , InfoProcName (..)
                                   , InfoLineNumber (..)

                                   , LAInterface (..)
                                   , LATdsVersion (..)
                                   , LAProgName (..)
                                   , LAProgVersion (..)
                                   
                                   , Offset (..)
                                   , OffsetIdentifier (..)
                                   , OffsetLength (..)
                                   
                                   , ReturnValue (..)
                                   , RVParamOrdinal (..)
                                   , RVParamName (..)
                                   , RVStatus (..)
                                   , RVUserType (..)
                                   , RVFlags (..)
                                   
                                   , RowColumnData (..)
                                   , TextPointer (..)
                                   , TimeStamp (..)

                                   ) where

import Control.Applicative((<$>),(<*>))

import qualified Data.ByteString as B
import qualified Data.ByteString.Lazy as LB

import qualified Data.Text as T
import qualified Data.Text.Encoding as T

import Data.Word (Word8(..),Word16(..),Word32(..),Word64(..))
import Data.Int (Int8(..),Int16(..),Int32(..),Int64(..))

import Data.Binary (Put(..),Get(..),Binary(..))
import qualified Data.Binary.Put as Put
import qualified Data.Binary.Get as Get

import Data.Bits ((.&.),(.|.),xor,shift)

import Control.Monad.State (StateT(..),evalStateT,put,get,modify)
import Control.Monad.Trans (lift)

import Database.Tds.Message.Prelogin
import Database.Tds.Message.DataStream



type MCDUserType = Word16
type MCDFlags = Word16
type MCDTableName = T.Text
type MCDColName = T.Text

data MetaColumnData = MetaColumnData !MCDUserType !MCDFlags !TypeInfo !(Maybe MCDTableName) !MCDColName
                    deriving (Int -> MetaColumnData -> ShowS
[MetaColumnData] -> ShowS
MetaColumnData -> String
(Int -> MetaColumnData -> ShowS)
-> (MetaColumnData -> String)
-> ([MetaColumnData] -> ShowS)
-> Show MetaColumnData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MetaColumnData] -> ShowS
$cshowList :: [MetaColumnData] -> ShowS
show :: MetaColumnData -> String
$cshow :: MetaColumnData -> String
showsPrec :: Int -> MetaColumnData -> ShowS
$cshowsPrec :: Int -> MetaColumnData -> ShowS
Show)


type RVParamOrdinal = Word16
type RVParamName = T.Text
type RVStatus = Word8
type RVUserType = Word16 -- [MEMO] TDS 7.2 -> Word32
type RVFlags = Word16

data ReturnValue = ReturnValue !RVParamOrdinal !RVParamName !RVStatus !RVUserType !RVFlags !TypeInfo !RawBytes
                 deriving (Int -> ReturnValue -> ShowS
[ReturnValue] -> ShowS
ReturnValue -> String
(Int -> ReturnValue -> ShowS)
-> (ReturnValue -> String)
-> ([ReturnValue] -> ShowS)
-> Show ReturnValue
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ReturnValue] -> ShowS
$cshowList :: [ReturnValue] -> ShowS
show :: ReturnValue -> String
$cshow :: ReturnValue -> String
showsPrec :: Int -> ReturnValue -> ShowS
$cshowsPrec :: Int -> ReturnValue -> ShowS
Show)


-- [MEMO] not newtype for (TDS 7.4 CekTable)
data ColMetaData = ColMetaData ![MetaColumnData]
                 deriving (Int -> ColMetaData -> ShowS
[ColMetaData] -> ShowS
ColMetaData -> String
(Int -> ColMetaData -> ShowS)
-> (ColMetaData -> String)
-> ([ColMetaData] -> ShowS)
-> Show ColMetaData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColMetaData] -> ShowS
$cshowList :: [ColMetaData] -> ShowS
show :: ColMetaData -> String
$cshow :: ColMetaData -> String
showsPrec :: Int -> ColMetaData -> ShowS
$cshowsPrec :: Int -> ColMetaData -> ShowS
Show)


-- [TODO] implement data type
data AltMetaData = AltMetaData
                 deriving (Int -> AltMetaData -> ShowS
[AltMetaData] -> ShowS
AltMetaData -> String
(Int -> AltMetaData -> ShowS)
-> (AltMetaData -> String)
-> ([AltMetaData] -> ShowS)
-> Show AltMetaData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AltMetaData] -> ShowS
$cshowList :: [AltMetaData] -> ShowS
show :: AltMetaData -> String
$cshow :: AltMetaData -> String
showsPrec :: Int -> AltMetaData -> ShowS
$cshowsPrec :: Int -> AltMetaData -> ShowS
Show)

-- [TODO] implement data type
data AltRowData = AltRowData
                deriving (Int -> AltRowData -> ShowS
[AltRowData] -> ShowS
AltRowData -> String
(Int -> AltRowData -> ShowS)
-> (AltRowData -> String)
-> ([AltRowData] -> ShowS)
-> Show AltRowData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [AltRowData] -> ShowS
$cshowList :: [AltRowData] -> ShowS
show :: AltRowData -> String
$cshow :: AltRowData -> String
showsPrec :: Int -> AltRowData -> ShowS
$cshowsPrec :: Int -> AltRowData -> ShowS
Show)


type OffsetIdentifier = Word16
type OffsetLength = Word16

data Offset = Offset !OffsetIdentifier !OffsetLength
            deriving (Int -> Offset -> ShowS
[Offset] -> ShowS
Offset -> String
(Int -> Offset -> ShowS)
-> (Offset -> String) -> ([Offset] -> ShowS) -> Show Offset
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Offset] -> ShowS
$cshowList :: [Offset] -> ShowS
show :: Offset -> String
$cshow :: Offset -> String
showsPrec :: Int -> Offset -> ShowS
$cshowsPrec :: Int -> Offset -> ShowS
Show)


data MetaData = MetaData !(Maybe ColMetaData) !(Maybe AltMetaData)
              deriving (Int -> MetaData -> ShowS
[MetaData] -> ShowS
MetaData -> String
(Int -> MetaData -> ShowS)
-> (MetaData -> String) -> ([MetaData] -> ShowS) -> Show MetaData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [MetaData] -> ShowS
$cshowList :: [MetaData] -> ShowS
show :: MetaData -> String
$cshow :: MetaData -> String
showsPrec :: Int -> MetaData -> ShowS
$cshowsPrec :: Int -> MetaData -> ShowS
Show)



type TextPointer = B.ByteString
type TimeStamp = Word64

data RowColumnData = RCDOrdinal !RawBytes
                   | RCDLarge !(Maybe TextPointer) !(Maybe TimeStamp) !RawBytes
                   deriving (Int -> RowColumnData -> ShowS
[RowColumnData] -> ShowS
RowColumnData -> String
(Int -> RowColumnData -> ShowS)
-> (RowColumnData -> String)
-> ([RowColumnData] -> ShowS)
-> Show RowColumnData
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [RowColumnData] -> ShowS
$cshowList :: [RowColumnData] -> ShowS
show :: RowColumnData -> String
$cshow :: RowColumnData -> String
showsPrec :: Int -> RowColumnData -> ShowS
$cshowsPrec :: Int -> RowColumnData -> ShowS
Show)


type CPColNum = Word8
type CPTableNum = Word8
type CPStatus = Word8
type CPColName = T.Text
data ColProperty = ColProperty !CPColNum !CPTableNum !CPStatus !(Maybe CPColName)
                 deriving (Int -> ColProperty -> ShowS
[ColProperty] -> ShowS
ColProperty -> String
(Int -> ColProperty -> ShowS)
-> (ColProperty -> String)
-> ([ColProperty] -> ShowS)
-> Show ColProperty
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [ColProperty] -> ShowS
$cshowList :: [ColProperty] -> ShowS
show :: ColProperty -> String
$cshow :: ColProperty -> String
showsPrec :: Int -> ColProperty -> ShowS
$cshowsPrec :: Int -> ColProperty -> ShowS
Show)

type DoneStatus = Word16
type DoneCurCmd = Word16
type DoneRowCount = Int32 -- [MEMO] TDS 7.2 -> Word64
data Done = Done !DoneStatus !DoneCurCmd !DoneRowCount
          deriving (Int -> Done -> ShowS
[Done] -> ShowS
Done -> String
(Int -> Done -> ShowS)
-> (Done -> String) -> ([Done] -> ShowS) -> Show Done
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Done] -> ShowS
$cshowList :: [Done] -> ShowS
show :: Done -> String
$cshow :: Done -> String
showsPrec :: Int -> Done -> ShowS
$cshowsPrec :: Int -> Done -> ShowS
Show)

type ECType = Word8 -- [TODO] To be detailed
type ECNewValue = B.ByteString
type ECOldValue = B.ByteString

type InfoNumber = Int32
type InfoState = Word8
type InfoClass = Word8
type InfoMsgText = T.Text
type InfoServerName = T.Text
type InfoProcName = T.Text
type InfoLineNumber = Word16 -- [MEMO] TDS 7.2 -> (error:Int32,info:Word32)
data Info = Info !InfoNumber !InfoState !InfoClass !InfoMsgText !InfoServerName !InfoProcName !InfoLineNumber
          deriving (Int -> Info -> ShowS
[Info] -> ShowS
Info -> String
(Int -> Info -> ShowS)
-> (Info -> String) -> ([Info] -> ShowS) -> Show Info
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [Info] -> ShowS
$cshowList :: [Info] -> ShowS
show :: Info -> String
$cshow :: Info -> String
showsPrec :: Int -> Info -> ShowS
$cshowsPrec :: Int -> Info -> ShowS
Show)

type LAInterface = Word8
type LATdsVersion = Word32
type LAProgName = T.Text
type LAProgVersion = Word32 -- [TODO] split bytes

-- | [\[MS-TDS\] 2.2.7 Packet Data Token Stream Definition](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/67b6113c-d722-42d1-902c-3f6e8de09173)
data TokenStream =
                 -- | [\[MS-TDS\] 2.2.7.1 ALTMETADATA](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/004bba4a-8c23-4d7b-ab2c-d9e7ba864cd0) (not supprted)
                   TSAltMetaData !AltMetaData

                 -- | [\[MS-TDS\] 2.2.7.2 ALTROW](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/d1c42761-6a64-43ab-8a55-fccb210ac073) (not supprted)
                 | TSAltRow !AltRowData

                 -- | [\[MS-TDS\] 2.2.7.3 COLINFO](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/aa8466c5-ca3d-48ca-a638-7c1becebe754)
                 | TSColInfo ![ColProperty]

                 -- | [\[MS-TDS\] 2.2.7.4 COLMETADATA](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/58880b9f-381c-43b2-bf8b-0727a98c4f4c)
                 | TSColMetaData !(Maybe ColMetaData)

                 -- | [\[MS-TDS\] 2.2.7.5 DONE](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/3c06f110-98bd-4d5b-b836-b1ba66452cb7)
                 | TSDone !Done

                 -- | [\[MS-TDS\] 2.2.7.6 DONEINPROC](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/43e891c5-f7a1-432f-8f9f-233c4cd96afb)
                 | TSDoneInProc !Done

                 -- | [\[MS-TDS\] 2.2.7.7 DONEPROC](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/65e24140-edea-46e5-b710-209af2016195)
                 | TSDoneProc !Done

                 -- | [\[MS-TDS\] 2.2.7.8 ENVCHANGE](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/2b3eb7e5-d43d-4d1b-bf4d-76b9e3afc791)
                 | TSEnvChange !ECType !ECNewValue !ECOldValue

                 -- | [\[MS-TDS\] 2.2.7.9 ERROR](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/9805e9fa-1f8b-4cf8-8f78-8d2602228635)
                 | TSError !Info

                 -- | [\[MS-TDS\] 2.2.7.12 INFO](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/284bb815-d083-4ed5-b33a-bdc2492e322b)
                 | TSInfo !Info

                 -- | [\[MS-TDS\] 2.2.7.13 LOGINACK](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/490e563d-cc6e-4c86-bb95-ef0186b98032)
                 | TSLoginAck !LAInterface !LATdsVersion !LAProgName !LAProgVersion

                 -- | [\[MS-TDS\] 2.2.7.15 OFFSET](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/8d0b37ff-20c1-439e-8f31-1d7f136249b5) (not tested)
                 | TSOffset !Offset
                   
                 -- | [\[MS-TDS\] 2.2.7.16 ORDER](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/252759be-9d74-4435-809d-d55dd860ea78)
                 | TSOrder ![Word16]
                   
                 -- | [\[MS-TDS\] 2.2.7.17 RETURNSTATUS](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/c719f199-e71b-4187-90b9-94f78bd1870e)
                 | TSReturnStatus !Int32
                   
                 -- | [\[MS-TDS\] 2.2.7.18 RETURNVALUE](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/7091f6f6-b83d-4ed2-afeb-ba5013dfb18f)
                 | TSReturnValue !ReturnValue
                   
                 -- | [\[MS-TDS\] 2.2.7.19 ROW](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/3840ef93-3b10-4aca-9fd1-a210b8bb6d0c)
                 | TSRow ![RowColumnData]
                 
                 -- | [\[MS-TDS\] 2.2.7.21 SSPI](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/07e2bb7b-8ba6-445f-89b1-cc76d8bfa9c6) (not tested)
                 | TSSSPI !B.ByteString
                 
                 -- | [\[MS-TDS\] 2.2.7.22 TABNAME](https://docs.microsoft.com/en-us/openspecs/windows_protocols/ms-tds/140e3348-da08-409a-b6c3-f0fc9cee2d6e)
                 | TSTabName ![[T.Text]]
                   
                 deriving (Int -> TokenStream -> ShowS
[TokenStream] -> ShowS
TokenStream -> String
(Int -> TokenStream -> ShowS)
-> (TokenStream -> String)
-> ([TokenStream] -> ShowS)
-> Show TokenStream
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TokenStream] -> ShowS
$cshowList :: [TokenStream] -> ShowS
show :: TokenStream -> String
$cshow :: TokenStream -> String
showsPrec :: Int -> TokenStream -> ShowS
$cshowsPrec :: Int -> TokenStream -> ShowS
Show)


getTokenStreamS :: StateT MetaData Get TokenStream
getTokenStreamS :: StateT MetaData Get TokenStream
getTokenStreamS = do
  Word8
pt <- Get Word8 -> StateT MetaData Get Word8
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get Word8
Get.getWord8
  case Word8
pt of
    Word8
0x88 -> StateT MetaData Get TokenStream
getAltMetaDataS
    Word8
0xd3 -> StateT MetaData Get TokenStream
getAltRowS
    Word8
0xa5 -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getColInfo
    Word8
0x81 -> StateT MetaData Get TokenStream
getColMetaDataS
    Word8
0xfd -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getDone
    Word8
0xff -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getDoneInProc
    Word8
0xfe -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getDoneProc
    Word8
0xe3 -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getEnvChange
    Word8
0xaa -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getError
    Word8
0xab -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getInfo
    Word8
0xad -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getLoginAck
    Word8
0x78 -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getOffset
    Word8
0xa9 -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getOrder
    Word8
0x79 -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getReturnStatus
    Word8
0xac -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getReturnValue
    Word8
0xd1 -> StateT MetaData Get TokenStream
getRowS
    Word8
0xed -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getSSPI
    Word8
0xa4 -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get TokenStream
getTabName
    Word8
_ -> Get TokenStream -> StateT MetaData Get TokenStream
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Get TokenStream -> StateT MetaData Get TokenStream)
-> Get TokenStream -> StateT MetaData Get TokenStream
forall a b. (a -> b) -> a -> b
$ Word8 -> Get TokenStream
getOther Word8
pt
  where

     -- [TODO] find SQL statement that generates this type of packet, implementation
    getAltMetaDataS :: StateT MetaData Get TokenStream
    getAltMetaDataS :: StateT MetaData Get TokenStream
getAltMetaDataS =
      String -> StateT MetaData Get TokenStream
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"getTokenStreamS.getAltMetaDataS: packet type ALTMEATADA not supportd"
--      return $ TSAltMetaData AltMetaData

    -- [TODO] find SQL statement that generates this type of packet, implementation
    getAltRowS :: StateT MetaData Get TokenStream
    getAltRowS :: StateT MetaData Get TokenStream
getAltRowS =
      String -> StateT MetaData Get TokenStream
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"getTokenStreamS.getAltRowS: packet type ALTROW not supportd"
--      return $ TSAltRow AltRowData
    
    getColInfo :: Get TokenStream
    getColInfo :: Get TokenStream
getColInfo = do
      Int64
len <- Word16 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Int64) -> Get Word16 -> Get Int64
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word16
Get.getWord16le
      ByteString
bs  <- Int64 -> Get ByteString
Get.getLazyByteString Int64
len
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ [ColProperty] -> TokenStream
TSColInfo ([ColProperty] -> TokenStream) -> [ColProperty] -> TokenStream
forall a b. (a -> b) -> a -> b
$ Get [ColProperty] -> ByteString -> [ColProperty]
forall a. Get a -> ByteString -> a
Get.runGet (Int64 -> Get [ColProperty]
getColProperties Int64
len) ByteString
bs
      where
        getColProperties :: Int64 -> Get [ColProperty]
        getColProperties :: Int64 -> Get [ColProperty]
getColProperties Int64
len = Get [ColProperty]
f
          where
            f :: Get [ColProperty]
            f :: Get [ColProperty]
f = do
              Int64
br <- Get Int64
Get.bytesRead
              if Int64
br Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
>= Int64
len
                then [ColProperty] -> Get [ColProperty]
forall (m :: * -> *) a. Monad m => a -> m a
return []
                else do ColProperty
x  <- Get ColProperty
getColProperty
                        [ColProperty]
xs <- Get [ColProperty]
f
                        [ColProperty] -> Get [ColProperty]
forall (m :: * -> *) a. Monad m => a -> m a
return ([ColProperty] -> Get [ColProperty])
-> [ColProperty] -> Get [ColProperty]
forall a b. (a -> b) -> a -> b
$ ColProperty
xColProperty -> [ColProperty] -> [ColProperty]
forall a. a -> [a] -> [a]
:[ColProperty]
xs
            
        getColProperty :: Get ColProperty
        getColProperty :: Get ColProperty
getColProperty = do
          Word8
colNum   <- Get Word8
Get.getWord8
          Word8
tableNum <- Get Word8
Get.getWord8
          Word8
status   <- Get Word8
Get.getWord8
          Maybe Text
colName  <- if (Word8
status Word8 -> Word8 -> Word8
forall a. Bits a => a -> a -> a
.&. Word8
0x20 Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
/= Word8
0x00) -- [MEMO] DIFFERENT_NAME
                      then Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Get Text -> Get (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Text
getText8
                      else Maybe Text -> Get (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
forall a. Maybe a
Nothing
          ColProperty -> Get ColProperty
forall (m :: * -> *) a. Monad m => a -> m a
return (ColProperty -> Get ColProperty) -> ColProperty -> Get ColProperty
forall a b. (a -> b) -> a -> b
$ Word8 -> Word8 -> Word8 -> Maybe Text -> ColProperty
ColProperty Word8
colNum Word8
tableNum Word8
status Maybe Text
colName
      
    
    getColMetaDataS :: StateT MetaData Get TokenStream
    getColMetaDataS :: StateT MetaData Get TokenStream
getColMetaDataS = do
      Word16
cols <- Get Word16 -> StateT MetaData Get Word16
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift Get Word16
Get.getWord16le
      if Word16
cols Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
== Word16
0xffff
        then TokenStream -> StateT MetaData Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> StateT MetaData Get TokenStream)
-> TokenStream -> StateT MetaData Get TokenStream
forall a b. (a -> b) -> a -> b
$ Maybe ColMetaData -> TokenStream
TSColMetaData Maybe ColMetaData
forall a. Maybe a
Nothing
        else do Maybe ColMetaData
cmd <- Get (Maybe ColMetaData) -> StateT MetaData Get (Maybe ColMetaData)
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Get (Maybe ColMetaData)
 -> StateT MetaData Get (Maybe ColMetaData))
-> Get (Maybe ColMetaData)
-> StateT MetaData Get (Maybe ColMetaData)
forall a b. (a -> b) -> a -> b
$ ColMetaData -> Maybe ColMetaData
forall a. a -> Maybe a
Just (ColMetaData -> Maybe ColMetaData)
-> ([MetaColumnData] -> ColMetaData)
-> [MetaColumnData]
-> Maybe ColMetaData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [MetaColumnData] -> ColMetaData
ColMetaData ([MetaColumnData] -> Maybe ColMetaData)
-> Get [MetaColumnData] -> Get (Maybe ColMetaData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Int -> Int -> Get [MetaColumnData]
getColumnDatas (Word16 -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral Word16
cols) Int
0
                (MetaData -> MetaData) -> StateT MetaData Get ()
forall s (m :: * -> *). MonadState s m => (s -> s) -> m ()
modify ((MetaData -> MetaData) -> StateT MetaData Get ())
-> (MetaData -> MetaData) -> StateT MetaData Get ()
forall a b. (a -> b) -> a -> b
$ \(MetaData Maybe ColMetaData
_ Maybe AltMetaData
mamd) -> (Maybe ColMetaData -> Maybe AltMetaData -> MetaData
MetaData Maybe ColMetaData
cmd Maybe AltMetaData
mamd)
                TokenStream -> StateT MetaData Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> StateT MetaData Get TokenStream)
-> TokenStream -> StateT MetaData Get TokenStream
forall a b. (a -> b) -> a -> b
$ Maybe ColMetaData -> TokenStream
TSColMetaData Maybe ColMetaData
cmd
        where
          getColumnDatas :: Int -> Int -> Get [MetaColumnData]
          getColumnDatas :: Int -> Int -> Get [MetaColumnData]
getColumnDatas Int
max Int
cnt =
            if Int
cnt Int -> Int -> Bool
forall a. Ord a => a -> a -> Bool
>= Int
max
              then [MetaColumnData] -> Get [MetaColumnData]
forall (m :: * -> *) a. Monad m => a -> m a
return []
              else do MetaColumnData
x  <- Get MetaColumnData
getColumnData
                      [MetaColumnData]
xs <- Int -> Int -> Get [MetaColumnData]
getColumnDatas Int
max (Int
cntInt -> Int -> Int
forall a. Num a => a -> a -> a
+Int
1)
                      [MetaColumnData] -> Get [MetaColumnData]
forall (m :: * -> *) a. Monad m => a -> m a
return ([MetaColumnData] -> Get [MetaColumnData])
-> [MetaColumnData] -> Get [MetaColumnData]
forall a b. (a -> b) -> a -> b
$ MetaColumnData
xMetaColumnData -> [MetaColumnData] -> [MetaColumnData]
forall a. a -> [a] -> [a]
:[MetaColumnData]
xs
                
          getColumnData :: Get MetaColumnData
          getColumnData :: Get MetaColumnData
getColumnData = do
            Word16
userType <- Get Word16
Get.getWord16le
            Word16
flags <- Get Word16
Get.getWord16le
            TypeInfo
typeInfo <- Get TypeInfo
forall t. Binary t => Get t
Data.Binary.get
            Maybe Text
maybeTableName <- case TypeInfo
typeInfo of
              TIText{}  -> Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Get Text -> Get (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Text
getText16
              TINText{} -> Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Get Text -> Get (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Text
getText16
              TIImage{} -> Text -> Maybe Text
forall a. a -> Maybe a
Just (Text -> Maybe Text) -> Get Text -> Get (Maybe Text)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Text
getText16
              TypeInfo
_ -> Maybe Text -> Get (Maybe Text)
forall (m :: * -> *) a. Monad m => a -> m a
return Maybe Text
forall a. Maybe a
Nothing
            Text
col <- Get Text
getText8
            
            MetaColumnData -> Get MetaColumnData
forall (m :: * -> *) a. Monad m => a -> m a
return (MetaColumnData -> Get MetaColumnData)
-> MetaColumnData -> Get MetaColumnData
forall a b. (a -> b) -> a -> b
$ Word16
-> Word16 -> TypeInfo -> Maybe Text -> Text -> MetaColumnData
MetaColumnData Word16
userType Word16
flags TypeInfo
typeInfo Maybe Text
maybeTableName Text
col



    getDone :: Get TokenStream
    getDone :: Get TokenStream
getDone = do
      Word16
status <- Get Word16
Get.getWord16le
      Word16
curCmd <- Get Word16
Get.getWord16le
      Int32
doneRowCount <- Get Int32
Get.getInt32le -- [MEMO] TDS 7.2 -> Word64
--      doneRowCount <- Get.getWord64le
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ Done -> TokenStream
TSDone (Done -> TokenStream) -> Done -> TokenStream
forall a b. (a -> b) -> a -> b
$ Word16 -> Word16 -> Int32 -> Done
Done Word16
status Word16
curCmd Int32
doneRowCount
          
    getDoneInProc :: Get TokenStream
    getDoneInProc :: Get TokenStream
getDoneInProc = do
      Word16
status <- Get Word16
Get.getWord16le
      Word16
curCmd <- Get Word16
Get.getWord16le
      Int32
doneRowCount <- Get Int32
Get.getInt32le -- [MEMO] TDS 7.2 -> Word64
--      doneRowCount <- Get.getWord64le
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ Done -> TokenStream
TSDoneInProc (Done -> TokenStream) -> Done -> TokenStream
forall a b. (a -> b) -> a -> b
$ Word16 -> Word16 -> Int32 -> Done
Done Word16
status Word16
curCmd Int32
doneRowCount
          
    getDoneProc :: Get TokenStream
    getDoneProc :: Get TokenStream
getDoneProc = do
      Word16
status <- Get Word16
Get.getWord16le
      Word16
curCmd <- Get Word16
Get.getWord16le
      Int32
doneRowCount <- Get Int32
Get.getInt32le -- [MEMO] TDS 7.2 -> Word64
--      doneRowCount <- Get.getWord64le
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ Done -> TokenStream
TSDoneProc (Done -> TokenStream) -> Done -> TokenStream
forall a b. (a -> b) -> a -> b
$ Word16 -> Word16 -> Int32 -> Done
Done Word16
status Word16
curCmd Int32
doneRowCount
          

    getEnvChange :: Get TokenStream
    getEnvChange :: Get TokenStream
getEnvChange = do
      Word16
slen  <- Get Word16
Get.getWord16le
      Word8
envCode <- Get Word8
Get.getWord8
      -- [TODO] to be detailed types
      (ByteString
old,ByteString
new) <- case Word8
envCode of
        Word8
0x07 -> do -- [MEMO] report SQL Collation
          Word8
oldLen <- Get Word8
Get.getWord8
          ByteString
old <- Word8 -> Get ByteString
forall a. Integral a => a -> Get ByteString
getByteString Word8
oldLen
          Word8
newLen <- Get Word8
Get.getWord8
          ByteString
new <- Word8 -> Get ByteString
forall a. Integral a => a -> Get ByteString
getByteString Word8
newLen
          (ByteString, ByteString) -> Get (ByteString, ByteString)
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString
old,ByteString
new)
        Word8
_ -> do
          Word8
oldLen <- Get Word8
Get.getWord8
          ByteString
old <- Word8 -> Get ByteString
forall a. Integral a => a -> Get ByteString
getByteString (Word8 -> Get ByteString) -> Word8 -> Get ByteString
forall a b. (a -> b) -> a -> b
$ Word8
oldLen Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
* Word8
2
          Word8
newLen <- Get Word8
Get.getWord8
          ByteString
new <- Word8 -> Get ByteString
forall a. Integral a => a -> Get ByteString
getByteString (Word8 -> Get ByteString) -> Word8 -> Get ByteString
forall a b. (a -> b) -> a -> b
$ Word8
newLen Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
* Word8
2
          (ByteString, ByteString) -> Get (ByteString, ByteString)
forall (m :: * -> *) a. Monad m => a -> m a
return (ByteString
old,ByteString
new)
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ Word8 -> ByteString -> ByteString -> TokenStream
TSEnvChange Word8
envCode ByteString
old ByteString
new


    
    getError :: Get TokenStream
    getError :: Get TokenStream
getError = do
      Word16
slen  <- Get Word16
Get.getWord16le
      Int32
number <- Get Int32
Get.getInt32le
      Word8
state <- Get Word8
Get.getWord8
      Word8
mclass <- Get Word8
Get.getWord8
      Text
message <- Get Text
getText16
      Text
server <- Get Text
getText8
      Text
process <- Get Text
getText8

      Word16
line <- Get Word16
Get.getWord16le -- [MEMO] TDS 7.2 -> Int32
--      line <- Get.getInt32le
          
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ Info -> TokenStream
TSError (Info -> TokenStream) -> Info -> TokenStream
forall a b. (a -> b) -> a -> b
$ Int32 -> Word8 -> Word8 -> Text -> Text -> Text -> Word16 -> Info
Info Int32
number Word8
state Word8
mclass Text
message Text
server Text
process Word16
line


    getInfo :: Get TokenStream
    getInfo :: Get TokenStream
getInfo = do
      Word16
slen  <- Get Word16
Get.getWord16le
      Int32
number <- Get Int32
Get.getInt32le
      Word8
state <- Get Word8
Get.getWord8
      Word8
mclass <- Get Word8
Get.getWord8
      Text
message <- Get Text
getText16
      Text
server <- Get Text
getText8
      Text
process <- Get Text
getText8

      Word16
line <- Get Word16
Get.getWord16le -- [MEMO] TDS 7.2 -> Word32
--      line <- Get.getWord32le
          
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ Info -> TokenStream
TSInfo (Info -> TokenStream) -> Info -> TokenStream
forall a b. (a -> b) -> a -> b
$ Int32 -> Word8 -> Word8 -> Text -> Text -> Text -> Word16 -> Info
Info Int32
number Word8
state Word8
mclass Text
message Text
server Text
process Word16
line


    getLoginAck :: Get TokenStream
    getLoginAck :: Get TokenStream
getLoginAck = do
      Word16
slen  <- Get Word16
Get.getWord16le
      Word8
interface <- Get Word8
Get.getWord8
      Word32
tdsVer <- Get Word32
Get.getWord32be
      Word8
serverLen <- Get Word8
Get.getWord8
      ByteString
bserver <- Word8 -> Get ByteString
forall a. Integral a => a -> Get ByteString
getByteString (Word8 -> Get ByteString) -> Word8 -> Get ByteString
forall a b. (a -> b) -> a -> b
$ Word8
serverLen Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
* Word8
2
      let
        bserver' :: ByteString
bserver' = Int -> ByteString -> ByteString
B.take (ByteString -> Int
B.length ByteString
bserver Int -> Int -> Int
forall a. Num a => a -> a -> a
-Int
4) ByteString
bserver
        server :: Text
server   = ByteString -> Text
T.decodeUtf16LE ByteString
bserver'
      Word32
servVer <- Get Word32
Get.getWord32be
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ Word8 -> Word32 -> Text -> Word32 -> TokenStream
TSLoginAck Word8
interface Word32
tdsVer Text
server Word32
servVer


    -- [TODO] find SQL statement that generates this type of packet, test
    getOffset :: Get TokenStream
    getOffset :: Get TokenStream
getOffset = do
      Offset
ofs <- Word16 -> Word16 -> Offset
Offset (Word16 -> Word16 -> Offset)
-> Get Word16 -> Get (Word16 -> Offset)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word16
Get.getWord16le Get (Word16 -> Offset) -> Get Word16 -> Get Offset
forall (f :: * -> *) a b. Applicative f => f (a -> b) -> f a -> f b
<*> Get Word16
Get.getWord16le
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ Offset -> TokenStream
TSOffset Offset
ofs

    getOrder :: Get TokenStream
    getOrder :: Get TokenStream
getOrder = do
      Word16
len <- Get Word16
Get.getWord16le
      [Word16]
nums <- (Word16 -> Get Word16) -> [Word16] -> Get [Word16]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\Word16
_ -> Get Word16
Get.getWord16le) [Word16
1..(Word16 -> Word16 -> Word16
forall a. Integral a => a -> a -> a
div Word16
len  Word16
2)]
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ [Word16] -> TokenStream
TSOrder [Word16]
nums

    getReturnStatus :: Get TokenStream
    getReturnStatus :: Get TokenStream
getReturnStatus = do
      Int32
val <- Get Int32
Get.getInt32le
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ Int32 -> TokenStream
TSReturnStatus Int32
val

    getReturnValue :: Get TokenStream
    getReturnValue :: Get TokenStream
getReturnValue = do
      Word16
po <- Get Word16
Get.getWord16le
      Text
pn <- Get Text
getText8
      Word8
st <- Get Word8
Get.getWord8
      Word16
ut <- Get Word16
Get.getWord16le -- [MEMO] TDS 7.2 -> Word32
--      ut <- Get.getWord32le
      Word16
fl <- Get Word16
Get.getWord16le
      TypeInfo
ti <- Get TypeInfo
forall t. Binary t => Get t
Data.Binary.get
      RawBytes
vl <- TypeInfo -> Get RawBytes
getRawBytes TypeInfo
ti
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ ReturnValue -> TokenStream
TSReturnValue (ReturnValue -> TokenStream) -> ReturnValue -> TokenStream
forall a b. (a -> b) -> a -> b
$ Word16
-> Text
-> Word8
-> Word16
-> Word16
-> TypeInfo
-> RawBytes
-> ReturnValue
ReturnValue Word16
po Text
pn Word8
st Word16
ut Word16
fl TypeInfo
ti RawBytes
vl


    getRowS :: StateT MetaData Get TokenStream
    getRowS :: StateT MetaData Get TokenStream
getRowS = do
      -- [TODO] raise error when Nothing
      Just (ColMetaData [MetaColumnData]
colDatas) <- (\(MetaData Maybe ColMetaData
mcmd Maybe AltMetaData
mamd) -> Maybe ColMetaData
mcmd) (MetaData -> Maybe ColMetaData)
-> StateT MetaData Get MetaData
-> StateT MetaData Get (Maybe ColMetaData)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> StateT MetaData Get MetaData
forall s (m :: * -> *). MonadState s m => m s
Control.Monad.State.get
      [RowColumnData]
datas <- Get [RowColumnData] -> StateT MetaData Get [RowColumnData]
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (Get [RowColumnData] -> StateT MetaData Get [RowColumnData])
-> Get [RowColumnData] -> StateT MetaData Get [RowColumnData]
forall a b. (a -> b) -> a -> b
$ (MetaColumnData -> Get RowColumnData)
-> [MetaColumnData] -> Get [RowColumnData]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (TypeInfo -> Get RowColumnData
getColumnData (TypeInfo -> Get RowColumnData)
-> (MetaColumnData -> TypeInfo)
-> MetaColumnData
-> Get RowColumnData
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (\(MetaColumnData Word16
_ Word16
_ TypeInfo
ti Maybe Text
_ Text
_) -> TypeInfo
ti)) [MetaColumnData]
colDatas
      TokenStream -> StateT MetaData Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> StateT MetaData Get TokenStream)
-> TokenStream -> StateT MetaData Get TokenStream
forall a b. (a -> b) -> a -> b
$ [RowColumnData] -> TokenStream
TSRow [RowColumnData]
datas
        where
          getColumnData :: TypeInfo -> Get RowColumnData
          getColumnData :: TypeInfo -> Get RowColumnData
getColumnData TypeInfo
ti = do
            case TypeInfo
ti of
              TIText{}  -> TypeInfo -> Get RowColumnData
getCDLarge TypeInfo
ti
              TINText{} -> TypeInfo -> Get RowColumnData
getCDLarge TypeInfo
ti
              TIImage{} -> TypeInfo -> Get RowColumnData
getCDLarge TypeInfo
ti
              TypeInfo
_ -> RawBytes -> RowColumnData
RCDOrdinal (RawBytes -> RowColumnData) -> Get RawBytes -> Get RowColumnData
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> TypeInfo -> Get RawBytes
getRawBytes TypeInfo
ti

          getCDLarge :: TypeInfo -> Get RowColumnData
          getCDLarge :: TypeInfo -> Get RowColumnData
getCDLarge TypeInfo
ti = do
            Word8
len <- Get Word8
Get.getWord8
            if Word8
len Word8 -> Word8 -> Bool
forall a. Eq a => a -> a -> Bool
== Word8
0
              then do
                -- [MEMO] should read 32bit ?
                case TypeInfo
ti of
                  TIText{}  -> RowColumnData -> Get RowColumnData
forall (m :: * -> *) a. Monad m => a -> m a
return (RowColumnData -> Get RowColumnData)
-> RowColumnData -> Get RowColumnData
forall a b. (a -> b) -> a -> b
$ Maybe ByteString -> Maybe TimeStamp -> RawBytes -> RowColumnData
RCDLarge Maybe ByteString
forall a. Maybe a
Nothing Maybe TimeStamp
forall a. Maybe a
Nothing RawBytes
forall a. Maybe a
Nothing
                  TINText{} -> RowColumnData -> Get RowColumnData
forall (m :: * -> *) a. Monad m => a -> m a
return (RowColumnData -> Get RowColumnData)
-> RowColumnData -> Get RowColumnData
forall a b. (a -> b) -> a -> b
$ Maybe ByteString -> Maybe TimeStamp -> RawBytes -> RowColumnData
RCDLarge Maybe ByteString
forall a. Maybe a
Nothing Maybe TimeStamp
forall a. Maybe a
Nothing RawBytes
forall a. Maybe a
Nothing
                  TIImage{} -> RowColumnData -> Get RowColumnData
forall (m :: * -> *) a. Monad m => a -> m a
return (RowColumnData -> Get RowColumnData)
-> RowColumnData -> Get RowColumnData
forall a b. (a -> b) -> a -> b
$ Maybe ByteString -> Maybe TimeStamp -> RawBytes -> RowColumnData
RCDLarge Maybe ByteString
forall a. Maybe a
Nothing Maybe TimeStamp
forall a. Maybe a
Nothing RawBytes
forall a. Maybe a
Nothing
              else do ByteString
tp <- Word8 -> Get ByteString
forall a. Integral a => a -> Get ByteString
getByteString Word8
len
                      TimeStamp
ts <- Get TimeStamp
Get.getWord64le
                      RawBytes
dt <- TypeInfo -> Get RawBytes
getRawBytes TypeInfo
ti
                      RowColumnData -> Get RowColumnData
forall (m :: * -> *) a. Monad m => a -> m a
return (RowColumnData -> Get RowColumnData)
-> RowColumnData -> Get RowColumnData
forall a b. (a -> b) -> a -> b
$ Maybe ByteString -> Maybe TimeStamp -> RawBytes -> RowColumnData
RCDLarge (ByteString -> Maybe ByteString
forall a. a -> Maybe a
Just ByteString
tp) (TimeStamp -> Maybe TimeStamp
forall a. a -> Maybe a
Just TimeStamp
ts) RawBytes
dt


    -- [TODO] find SQL statement that generates this type of packet, test
    getSSPI :: Get TokenStream
    getSSPI :: Get TokenStream
getSSPI = do
      Word16
len <- Get Word16
Get.getWord16le
      ByteString
bs <- Word16 -> Get ByteString
forall a. Integral a => a -> Get ByteString
getByteString Word16
len
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ ByteString -> TokenStream
TSSSPI ByteString
bs
    
    getTabName :: Get TokenStream
    getTabName :: Get TokenStream
getTabName = do
      Int64
len <- Word16 -> Int64
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word16 -> Int64) -> Get Word16 -> Get Int64
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word16
Get.getWord16le
      ByteString
bs  <- Int64 -> Get ByteString
Get.getLazyByteString Int64
len
      TokenStream -> Get TokenStream
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStream -> Get TokenStream) -> TokenStream -> Get TokenStream
forall a b. (a -> b) -> a -> b
$ [[Text]] -> TokenStream
TSTabName ([[Text]] -> TokenStream) -> [[Text]] -> TokenStream
forall a b. (a -> b) -> a -> b
$ Get [[Text]] -> ByteString -> [[Text]]
forall a. Get a -> ByteString -> a
Get.runGet (Int64 -> Get [[Text]]
getAllTableNames Int64
len) ByteString
bs
      where
        getAllTableNames :: Int64 -> Get [[T.Text]]
        getAllTableNames :: Int64 -> Get [[Text]]
getAllTableNames Int64
len = Get [[Text]]
f
          where
            f :: Get [[T.Text]]
            f :: Get [[Text]]
f = do
              Int64
br <- Get Int64
Get.bytesRead
              if Int64
br Int64 -> Int64 -> Bool
forall a. Ord a => a -> a -> Bool
>= Int64
len
                then [[Text]] -> Get [[Text]]
forall (m :: * -> *) a. Monad m => a -> m a
return []
                else do [Text]
x <- Get [Text]
getTableName
                        [[Text]]
xs <-Get [[Text]]
f
                        [[Text]] -> Get [[Text]]
forall (m :: * -> *) a. Monad m => a -> m a
return ([[Text]] -> Get [[Text]]) -> [[Text]] -> Get [[Text]]
forall a b. (a -> b) -> a -> b
$ [Text]
x[Text] -> [[Text]] -> [[Text]]
forall a. a -> [a] -> [a]
:[[Text]]
xs

        getTableName :: Get [T.Text]
        getTableName :: Get [Text]
getTableName = do
          Integer
numParts <- Word8 -> Integer
forall a b. (Integral a, Num b) => a -> b
fromIntegral (Word8 -> Integer) -> Get Word8 -> Get Integer
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Get Word8
Get.getWord8
          [Text]
names <- (Integer -> Get Text) -> [Integer] -> Get [Text]
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
mapM (\Integer
_ -> Get Text
getText16 ) [Integer
1..Integer
numParts]
          [Text] -> Get [Text]
forall (m :: * -> *) a. Monad m => a -> m a
return [Text]
names
          
          
          

      
      
    getOther :: Word8 -> Get TokenStream
    getOther :: Word8 -> Get TokenStream
getOther Word8
pt = do
      case Word8
pt of
        Word8
0xae ->
          -- FEATUREEXTACK
          -- [MEMO] introduced in TDS 7.4
          String -> Get TokenStream
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"getTokenStreamS.getOther: packet type FEATUREEXTACK not supportd"
        Word8
0xee ->
          -- FEDAUTHINFO
          -- [MEMO] introduced in TDS 7.4
          String -> Get TokenStream
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"getTokenStreamS.getOther: packet type FEDAUTHINFO not supportd"
        Word8
0xd2 ->
          -- NBCROW
          -- [MEMO] introduced in TDS 7.3.B
          String -> Get TokenStream
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"getTokenStreamS.getOther: packet type NBCROW not supported"
        Word8
0xe4 ->
          -- SESSIONSTATE
          -- [MEMO] introduced in TDS 7.4
          String -> Get TokenStream
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"getTokenStreamS.getOther: packet type SESSIONSTATE not supportd"
        Word8
0x01 ->
          -- TVP ROW
          -- https://msdn.microsoft.com/en-us/library/dd304813.aspx
          -- [MEMO] not here ?
          -- [MEMO] introduced in TDS 7.3 ?
          String -> Get TokenStream
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"getTokenStreamS.getOther: packet type TVP ROW not supported"
        Word8
_ -> String -> Get TokenStream
forall (m :: * -> *) a. MonadFail m => String -> m a
fail String
"getTokenStreamS.getOther: invalid packet type"


          



getTokenStreamsS :: StateT MetaData Get [TokenStream]
getTokenStreamsS :: StateT MetaData Get [TokenStream]
getTokenStreamsS = StateT MetaData Get [TokenStream]
f
  where
    f :: StateT MetaData Get [TokenStream]
    f :: StateT MetaData Get [TokenStream]
f = do
      TokenStream
x <- StateT MetaData Get TokenStream
getTokenStreamS
      if TokenStream -> Bool
final TokenStream
x
        then [TokenStream] -> StateT MetaData Get [TokenStream]
forall (m :: * -> *) a. Monad m => a -> m a
return ([TokenStream] -> StateT MetaData Get [TokenStream])
-> [TokenStream] -> StateT MetaData Get [TokenStream]
forall a b. (a -> b) -> a -> b
$ TokenStream
x TokenStream -> [TokenStream] -> [TokenStream]
forall a. a -> [a] -> [a]
: []
        else do [TokenStream]
xs <- StateT MetaData Get [TokenStream]
f
                [TokenStream] -> StateT MetaData Get [TokenStream]
forall (m :: * -> *) a. Monad m => a -> m a
return ([TokenStream] -> StateT MetaData Get [TokenStream])
-> [TokenStream] -> StateT MetaData Get [TokenStream]
forall a b. (a -> b) -> a -> b
$ TokenStream
x TokenStream -> [TokenStream] -> [TokenStream]
forall a. a -> [a] -> [a]
: [TokenStream]
xs

    final :: TokenStream -> Bool
    final :: TokenStream -> Bool
final (TSDone (Done Word16
st Word16
_ Int32
_))       = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Word16 -> Bool
containsMoreBit Word16
st
    final (TSDoneInProc (Done Word16
st Word16
_ Int32
_)) = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Word16 -> Bool
containsMoreBit Word16
st
    final (TSDoneProc (Done Word16
st Word16
_ Int32
_))   = Bool -> Bool
not (Bool -> Bool) -> Bool -> Bool
forall a b. (a -> b) -> a -> b
$ Word16 -> Bool
containsMoreBit Word16
st
    final TokenStream
_ = Bool
False

    containsMoreBit :: Word16 -> Bool
    containsMoreBit :: Word16 -> Bool
containsMoreBit Word16
st = Word16
st Word16 -> Word16 -> Word16
forall a. Bits a => a -> a -> a
.&. Word16
0x01 Word16 -> Word16 -> Bool
forall a. Eq a => a -> a -> Bool
== Word16
0x01 -- [MEMO] 0x1 more bit



newtype TokenStreams = TokenStreams [TokenStream]
                     deriving (Int -> TokenStreams -> ShowS
[TokenStreams] -> ShowS
TokenStreams -> String
(Int -> TokenStreams -> ShowS)
-> (TokenStreams -> String)
-> ([TokenStreams] -> ShowS)
-> Show TokenStreams
forall a.
(Int -> a -> ShowS) -> (a -> String) -> ([a] -> ShowS) -> Show a
showList :: [TokenStreams] -> ShowS
$cshowList :: [TokenStreams] -> ShowS
show :: TokenStreams -> String
$cshow :: TokenStreams -> String
showsPrec :: Int -> TokenStreams -> ShowS
$cshowsPrec :: Int -> TokenStreams -> ShowS
Show)



getTokenStreams :: Get TokenStreams
getTokenStreams :: Get TokenStreams
getTokenStreams = do
  [TokenStream]
rs <- (StateT MetaData Get [TokenStream] -> MetaData -> Get [TokenStream]
forall (m :: * -> *) s a. Monad m => StateT s m a -> s -> m a
evalStateT StateT MetaData Get [TokenStream]
getTokenStreamsS) (Maybe ColMetaData -> Maybe AltMetaData -> MetaData
MetaData Maybe ColMetaData
forall a. Maybe a
Nothing Maybe AltMetaData
forall a. Maybe a
Nothing)
  TokenStreams -> Get TokenStreams
forall (m :: * -> *) a. Monad m => a -> m a
return (TokenStreams -> Get TokenStreams)
-> TokenStreams -> Get TokenStreams
forall a b. (a -> b) -> a -> b
$ [TokenStream] -> TokenStreams
TokenStreams [TokenStream]
rs


putTokenStreams :: TokenStreams -> Put
putTokenStreams :: TokenStreams -> Put
putTokenStreams = TokenStreams -> Put
forall a. HasCallStack => a
undefined -- [TODO] implement put function



instance Binary TokenStreams where
  put :: TokenStreams -> Put
put = TokenStreams -> Put
putTokenStreams
  get :: Get TokenStreams
get = Get TokenStreams
getTokenStreams




getByteString :: Integral a => a -> Get B.ByteString
getByteString :: a -> Get ByteString
getByteString a
len = Int -> Get ByteString
Get.getByteString (Int -> Get ByteString) -> Int -> Get ByteString
forall a b. (a -> b) -> a -> b
$ a -> Int
forall a b. (Integral a, Num b) => a -> b
fromIntegral a
len

getText :: Integral a => a -> Get T.Text
getText :: a -> Get Text
getText a
len = ByteString -> Text
T.decodeUtf16LE (ByteString -> Text) -> Get ByteString -> Get Text
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> a -> Get ByteString
forall a. Integral a => a -> Get ByteString
getByteString a
len

getText8 :: Get T.Text
getText8 :: Get Text
getText8 = Get Word8
Get.getWord8 Get Word8 -> (Word8 -> Get Text) -> Get Text
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Word8
len -> Word8 -> Get Text
forall a. Integral a => a -> Get Text
getText (Word8 -> Get Text) -> Word8 -> Get Text
forall a b. (a -> b) -> a -> b
$ Word8
len Word8 -> Word8 -> Word8
forall a. Num a => a -> a -> a
* Word8
2

getText16 :: Get T.Text
getText16 :: Get Text
getText16 = Get Word16
Get.getWord16le Get Word16 -> (Word16 -> Get Text) -> Get Text
forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
>>= \Word16
len -> Word16 -> Get Text
forall a. Integral a => a -> Get Text
getText (Word16 -> Get Text) -> Word16 -> Get Text
forall a b. (a -> b) -> a -> b
$ Word16
len Word16 -> Word16 -> Word16
forall a. Num a => a -> a -> a
* Word16
2