DBFunctor-0.1.0.0: src/Etl/Internal/Core.hs
{-|
Module : ETL
Description : Implements ETL operations over RTables.
Copyright : (c) Nikos Karagiannidis, 2018
License : BSD3
Maintainer : nkarag@gmail.com
Stability : stable
Portability : POSIX
This is an internal module (i.e., not to be imported directly) that implements the core ETL functionality
that is exposed via the __Julius__ EDSL for ETL/ELT found in the "Etl.Julius" module)
-}
{-# LANGUAGE OverloadedStrings #-}
-- :set -XOverloadedStrings
--{-# LANGUAGE OverloadedRecordFields #-}
--{-# LANGUAGE DuplicateRecordFields #-}
module Etl.Internal.Core
(
-- * Basic Data Types
RColMapping (..)
,ColXForm
,createColMapping
,ETLOperation (..)
,ETLMapping (..)
,YesNo (..)
-- * Execution of an ETL Mapping
,runCM
,etlOpU
,etlOpB
,etl
,etlRes
-- * Functions for \"Building\" an ETL Mapping
,rtabToETLMapping
,createLeafETLMapLD
,createLeafBinETLMapLD
,connectETLMapLD
-- * Various ETL Operations
,
) where
-- Data.RTable
import RTable.Core
-- Text
import Data.Text as T
-- HashMap -- https://hackage.haskell.org/package/unordered-containers-0.2.7.2/docs/Data-HashMap-Strict.html
import Data.HashMap.Strict as HM
-- Data.List
import Data.List (notElem, map, zip)
-- Data.Vector
import Data.Vector as V
data YesNo = Yes | No deriving (Eq, Show)
-- | This is the basic data type to define the column-to-column mapping from a source 'RTable' to a target 'RTable'.
-- Essentially, an 'RColMapping' represents the column-level transformations of an 'RTuple' that will yield a target 'RTuple'.
--
-- A mapping is simply a triple of the form ( Source-Column(s), Target-Column(s), Transformation, RTuple-Filter), where we define the source columns
-- over which a transformation (i.e. a function) will be applied in order to yield the target columns. Also, an 'RPredicate' (i.e. a filter) might be applied on the source 'RTuple'.
-- Remember that an 'RTuple' is essentially a mapping between a key (the Column Name) and a value (the 'RDataType' value). So the various 'RColMapping'
-- data constructors below simply describe the possible modifications of an 'RTuple' orginating from its own columns.
--
-- So, we can have the following mapping types:
-- a) single-source column to single-target column mapping (1 to 1),
-- the source column will be removed or not based on the 'removeSrcCol' flag (dublicate column names are not allowed in an 'RTuple')
-- b) multiple-source columns to single-target column mapping (N to 1),
-- The N columns will be merged to the single target column based on the transformation.
-- The N columns will be removed from the RTuple or not based on the 'removeSrcCol' flag (dublicate column names are not allowed in an 'RTuple')
-- c) single-source column to multiple-target columns mapping (1 to M)
-- the source column will be "expanded" to M target columns based ont he transformation.
-- the source column will be removed or not based on the 'removeSrcCol' flag (dublicate column names are not allowed in an 'RTuple')
-- d) multiple-source column to multiple target columns mapping (N to M)
-- The N source columns will be mapped to M target columns based on the transformation.
-- The N columns will be removed from the RTuple or not based on the 'removeSrcCol' flag (dublicate column names are not allow in an 'RTuple')
--
-- Some examples of mapping are the following:
--
-- @
-- ("Start_Date", No, "StartDate", \t -> True) -- copy the source value to target and dont remove the source column, so the target RTuple will have both columns "Start_Date" and "StartDate"
-- -- with the exactly the same value)
--
-- (["Amount", "Discount"], Yes, "FinalAmount", (\[a, d] -> a * d) ) -- "FinalAmount" is a derived column based on a function applied to the two source columns.
-- -- In the final RTuple we remove the two source columns.
-- @
--
-- An 'RColMapping' can be applied with the 'runCM' (runColMapping) operator
--
data RColMapping =
ColMapEmpty
| RMap1x1 { srcCol :: ColumnName, removeSrcCol :: YesNo, trgCol :: ColumnName, transform1x1 :: RDataType -> RDataType, srcRTupleFilter:: RPredicate } -- ^ single-source column to single-target column mapping (1 to 1).
| RMapNx1 { srcColGrp :: [ColumnName], removeSrcCol :: YesNo, trgCol :: ColumnName, transformNx1 :: [RDataType] -> RDataType, srcRTupleFilter:: RPredicate } -- ^ multiple-source columns to single-target column mapping (N to 1)
| RMap1xN { srcCol :: ColumnName, removeSrcCol :: YesNo, trgColGrp :: [ColumnName], transform1xN :: RDataType -> [RDataType], srcRTupleFilter:: RPredicate } -- ^ single-source column to multiple-target columns mapping (1 to N)
| RMapNxM { srcColGrp :: [ColumnName], removeSrcCol :: YesNo, trgColGrp :: [ColumnName], transformNxM :: [RDataType] -> [RDataType], srcRTupleFilter:: RPredicate } -- ^ multiple-source column to multiple target columns mapping (N to M)
-- | A Column Transformation function data type.
-- It is used in order to define an arbitrary column-level transformation (i.e., from a list of N input Column-Values we produce a list of M derived (output) Column-Values).
-- A Column value is represented with the 'RDataType'.
type ColXForm = [RDataType] -> [RDataType]
-- | Constructs an RColMapping.
-- This is the suggested method for creating a column mapping and not by calling the data constructors directly.
createColMapping ::
[ColumnName] -- ^ List of source column names
-> [ColumnName] -- ^ List of target column names
-> ColXForm -- ^ Column Transformation function
-> YesNo -- ^ Remove source column option
-> RPredicate -- ^ Filtering predicate
-> RColMapping -- ^ Output Column Mapping
createColMapping (src:[]) (trg:[]) xForm remove fPred = RMap1x1 {srcCol = src, removeSrcCol = remove, trgCol = trg, transform1x1 = \x -> unlist $ xForm (x:[]), srcRTupleFilter = fPred}
where unlist :: [a] -> a
unlist (x:[]) = x -- since this is a 1x1 col mapping, we are sure that xForm will return a single element list
createColMapping srcCols (trg:[]) xForm remove fPred = RMapNx1 {srcColGrp = srcCols, removeSrcCol = remove, trgCol = trg, transformNx1 = \x -> unlist $ xForm (x), srcRTupleFilter = fPred}
where unlist :: [a] -> a
unlist (x:[]) = x -- since this is a Nx1 col mapping, we are sure that xForm will return a single element list
createColMapping (src:[]) trgCols xForm remove fPred = RMap1xN {srcCol = src, removeSrcCol = remove, trgColGrp = trgCols, transform1xN = \x -> xForm (x:[]), srcRTupleFilter = fPred}
createColMapping srcCols trgCols xForm remove fPred = RMapNxM {srcColGrp = srcCols, removeSrcCol = remove, trgColGrp = trgCols, transformNxM = xForm, srcRTupleFilter = fPred}
-- | runCM operator executes an RColMapping
-- If a target-column has the same name with a source-column and a DontRemoveSrc (i.e., removeSrcCol == No) has been specified, then the (target-column, target-value) key-value pair,
-- overwrites the corresponding (source-column, source-value) key-value pair
runCM = runColMapping
-- | Apply an RColMapping to a source RTable and produce a new RTable.
-- If a target-column has the same name with a source-column and a DontRemoveSrc (i.e., removeSrcCol == No) has been specified, then the (target-column, target-value) key-value pair,
-- overwrites the corresponding (source-column, source-value) key-value pair.
-- If a filter is embedded in the 'RColMapping', then the returned 'RTable' will include only the 'RTuple's that satisfy the filter predicate.
runColMapping :: RColMapping -> RTable -> RTable
runColMapping ColMapEmpty rtabS = rtabS
runColMapping rmap rtabS =
if isRTabEmpty rtabS
then emptyRTable
else
case rmap of
RMap1x1 {srcCol = src, trgCol = trg, removeSrcCol = rmvFlag, transform1x1 = xform, srcRTupleFilter = pred} -> do -- an RTable is a Monad just like a list is a Monad, representing a non-deterministic value
srcRtuple <- f pred rtabS
let
-- 1. get original column value
srcValue = getRTupColValue src srcRtuple
-- srcValue = HM.lookupDefault Null -- return Null if value cannot be found based on column name
-- src -- column name to look for (source) - i.e., the key in the HashMap
-- srcRtuple -- source RTuple (i.e., a HashMap ColumnName RDataType)
-- 2. apply transformation to retrieve new column value
trgValue = xform srcValue
-- 3. remove the original ColumnName, Value mapping from the RTuple
rtupleTemp =
case rmvFlag of
Yes -> HM.delete src srcRtuple
No -> srcRtuple
-- 4. insert new (ColumnName, Value) pair and thus create the target RTuple
trgRtuple = HM.insert trg trgValue rtupleTemp
-- return new RTable
return trgRtuple
RMapNx1 {srcColGrp = srcL, trgCol = trg, removeSrcCol = rmvFlag, transformNx1 = xform, srcRTupleFilter = pred} -> do -- an RTable is a Monad just like a list is a Monad, representing a non-deterministic value
srcRtuple <- f pred rtabS
let
-- 1. get original column value (in this case it is a list of values)
srcValueL = Data.List.map ( \src -> getRTupColValue src srcRtuple
-- \src -> HM.lookupDefault Null -- return Null if value cannot be found based on column name
-- src -- column name to look for (source) - i.e., the key in the HashMap
-- srcRtuple -- source RTuple (i.e., a HashMap ColumnName RDataType)
) srcL
-- 2. apply transformation to retrieve new column value
trgValue = xform srcValueL
-- 3. remove the original (ColumnName, Value) mappings from the RTuple (i.e., remove ColumnNames mentioned in the RColMapping from source RTuple)
rtupleTemp =
case rmvFlag of
Yes -> HM.filterWithKey (\colName _ -> Data.List.notElem colName srcL) srcRtuple
No -> srcRtuple
-- 4. insert new ColumnName, Value mapping as the target RTuple must be
trgRtuple = HM.insert trg trgValue rtupleTemp
-- return new RTable
return trgRtuple
RMap1xN {srcCol = src, trgColGrp = trgL, removeSrcCol = rmvFlag, transform1xN = xform, srcRTupleFilter = pred} -> do -- an RTable is a Monad just like a list is a Monad, representing a non-deterministic value
srcRtuple <- f pred rtabS
let
-- 1. get original column value
srcValue = getRTupColValue src srcRtuple
-- srcValue = HM.lookupDefault Null -- return Null if value cannot be found based on column name
-- src -- column name to look for (source) - i.e., the key in the HashMap
-- srcRtuple -- source RTuple (i.e., a HashMap ColumnName RDataType)
-- 2. apply transformation to retrieve new column value list
trgValueL = xform srcValue
-- 3. remove the original ColumnName, Value mapping from the RTuple
rtupleTemp =
case rmvFlag of
Yes -> HM.delete src srcRtuple
No -> srcRtuple
-- 4. insert new (ColumnName, Value) pairs to the target RTuple
tempL = Data.List.zip trgL trgValueL
trgRtuple = HM.union (HM.fromList tempL) rtupleTemp -- implement as a hashmap union between new (columnName,value) pairs and source tuple
-- return new RTable
return trgRtuple
RMapNxM {srcColGrp = srcL, trgColGrp = trgL, removeSrcCol = rmvFlag, transformNxM = xform, srcRTupleFilter = pred} -> do -- an RTable is a Monad just like a list is a Monad, representing a non-deterministic value
srcRtuple <- f pred rtabS
let
-- 1. get original column value (in this case it is a list of values)
srcValueL = Data.List.map ( \src -> getRTupColValue src srcRtuple
-- \src -> HM.lookupDefault Null -- return Null if value cannot be found based on column name
-- src -- column name to look for (source) - i.e., the key in the HashMap
-- srcRtuple -- source RTuple (i.e., a HashMap ColumnName RDataType)
) srcL
-- 2. apply transformation to retrieve new column value
trgValueL = xform srcValueL
-- 3. remove the original ColumnName, Value mapping from the RTuple
rtupleTemp =
case rmvFlag of
Yes -> HM.filterWithKey (\colName _ -> Data.List.notElem colName srcL) srcRtuple
No -> srcRtuple
-- 4. insert new (ColumnName, Value) pairs to the target RTuple
tempL = Data.List.zip trgL trgValueL
trgRtuple = HM.union (HM.fromList tempL) rtupleTemp -- implement as a hashmap union between new (columnName,value) pairs and source tuple
-- return new RTable
return trgRtuple
-- | An ETL operation applied to an RTable can be either an 'ROperation' (a relational agebra operation like join, filter etc.) defined in "RTable.Core" module,
-- or an 'RColMapping' applied to an 'RTable'
data ETLOperation =
ETLrOp { rop :: ROperation }
| ETLcOp { cmap :: RColMapping }
-- | executes a Unary ETL Operation
etlOpU = runUnaryETLOperation
-- | executes an ETL Operation
runUnaryETLOperation ::
ETLOperation
-> RTable -- ^ input RTable
-> RTable -- ^ output RTable
runUnaryETLOperation op inpRtab =
case op of
ETLrOp { rop = relOp } -> ropU relOp inpRtab
ETLcOp { cmap = colMap } -> runCM colMap inpRtab
-- | executes a Binary ETL Operation
etlOpB = runBinaryETLOperation
-- | executes an ETL Operation
runBinaryETLOperation ::
ETLOperation
-> RTable -- ^ input RTable1
-> RTable -- ^ input RTable2
-> RTable -- ^ output RTable
runBinaryETLOperation ETLrOp {rop = relOp} inpT1 inpT2 = ropB relOp inpT1 inpT2
-- | ETLmapping : it is the equivalent of a mapping in an ETL tool and consists of a series of ETLOperations that are applied, one-by-one,
-- to some initial input RTable, but if binary ETLOperations are included in the ETLMapping, then there will be more than one input RTables that
-- the ETLOperations of the ETLMapping will be applied to. When we apply (i.e., run) an ETLOperation of the ETLMapping we get a new RTable,
-- which is then inputed to the next ETLOperation, until we finally run all ETLOperations. The purpose of the execution of an ETLMapping is
-- to produce a single new RTable as the result of the execution of all the ETLOperations of the ETLMapping.
-- In terms of database operations an ETLMapping is the equivalent of an CREATE AS SELECT (CTAS) operation in an RDBMS. This means that
-- anything that can be done in the SELECT part (i.e., column projection, row filtering, grouping and join operations, etc.)
-- in order to produce a new table, can be included in an ETLMapping.
--
-- An ETLMapping is executed with the etl (runETLmapping) operator
--
-- Implementation:
-- An ETLMapping is implemented as a binary tree where the node represents the ETLOperation to be executed and the left branch is another
-- ETLMapping, while the right branch is an RTable (that might be empty in the case of a Unary ETLOperation).
-- Execution proceeds from bottom-left to top-right.
-- This is similar in concept to a left-deep join tree. In a Left-Deep ETLOperation tree the "pipe" of ETLOperations comes from
-- the left branches always.
-- The leaf node is always an ETLMapping with an ETLMapEmpty in the left branch and an RTable in the right branch (the initial RTable inputed
-- to the ETLMapping).
-- In this way, the result of the execution of each ETLOperation (which is an RTable) is passed on to the next ETLOperation. Here is an example:
--
-- @
-- A Left-Deep ETLOperation Tree
--
-- final RTable result
-- /
-- etlOp3
-- / \
-- etlOp2 rtab2
-- / \
-- A leaf-node --> etlOp1 emptyRTab
-- / \
-- ETLMapEmpty rtab1
--
-- @
--
-- You see that always on the left branch we have an ETLMapping data type (i.e., a left-deep ETLOperation tree).
-- So how do we implement the following case?
--
-- @
--
-- final RTable result
-- /
-- A leaf-node --> etlOp1
-- / \
-- rtab1 rtab2
--
-- @
--
-- The answer is that we "model" the left RTable (rtab1 in our example) as an ETLMapping of the form:
--
-- @
-- ETLMapLD { etlOp = ETLcOp{cmap = ColMapEmpty}, tabL = ETLMapEmpty, tabR = rtab1 }
-- @
--
-- So we embed the rtab1 in a ETLMapping, which is a leaf (i.e., it has an empty prevMap), the rtab1 is in
-- the right branch (tabR) and the ETLOperation is the EmptyColMapping, which returns its input RTable when executed.
-- We can use function 'rtabToETLMapping' for this job. So it becomes
-- @
-- A leaf-node --> etlOp1
-- / \
-- rtabToETLMapping rtab1 rtab2
-- @
--
-- In this manner, a leaf-node can also be implemented like this:
--
-- @
-- final RTable result
-- /
-- etlOp3
-- / \
-- etlOp2 rtab2
-- / \
-- A leaf-node --> etlOp1 emptyRTab
-- / \
-- rtabToETLMapping rtab1 emptyRTable
-- @
--
data ETLMapping =
ETLMapEmpty -- ^ an empty node
| ETLMapLD
{ etlOp :: ETLOperation -- ^ the ETLOperation to be executed
,tabL :: ETLMapping -- ^ the left-branch corresponding to the previous ETLOperation, which is input to this one.
--
,tabR :: RTable -- ^ the right branch corresponds to another RTable (for binary ETL operations).
-- If this is a Unary ETLOperation then this field must be an empty RTable.
} -- ^ a Left-Deep node
| ETLMapRD
{ etlOp :: ETLOperation -- ^ the ETLOperation to be executed
,tabLrd :: RTable -- ^ the left-branch corresponds to another RTable (for binary ETL operations).
-- If this is a Unary ETLOperation then this field must be an empty RTable.
,tabRrd :: ETLMapping -- ^ the right branch corresponding to the previous ETLOperation, which is input to this one.
} -- ^ a Right-Deep node
| ETLMapBal
{ etlOp :: ETLOperation -- ^ the ETLOperation to be executed
,tabLbal :: ETLMapping -- ^ the left-branch corresponding to the previous ETLOperation, which is input to this one.
-- If this is a Unary ETLOperation then this field might be an empty ETLMapping.
,tabRbal :: ETLMapping -- ^ the right branch corresponding corresponding to the previous ETLOperation, which is input to this one. -- If this is a Unary ETLOperation then this field might be an empty ETLMapping.
} -- ^ a Balanced node
instance Eq ETLMapping where
etlMap1 == etlMap2 =
(etl etlMap1) == (etl etlMap2) -- two ETLMappings are equal if the RTables resulting from their execution are equal
-- | Creates a left-deep leaf ETL Mapping, of the following form:
--
-- @
-- A Left-Deep ETLOperation Tree
--
-- final RTable result
-- /
-- etlOp3
-- / \
-- etlOp2 rtab2
-- / \
-- A leaf-node --> etlOp1 emptyRTab
-- / \
-- ETLMapEmpty rtab1
--
-- @
--
createLeafETLMapLD ::
ETLOperation -- ^ ETL operation of this ETL mapping
-> RTable -- ^ input RTable
-> ETLMapping -- ^ output ETLMapping
createLeafETLMapLD etlop rt = ETLMapLD { etlOp = etlop, tabL = ETLMapEmpty, tabR = rt}
-- | creates a Binary operation leaf node of the form:
--
-- @
--
-- A leaf-node --> etlOp1
-- / \
-- rtabToETLMapping rtab1 rtab2
-- @
--
createLeafBinETLMapLD ::
ETLOperation -- ^ ETL operation of this ETL mapping
-> RTable -- ^ input RTable1
-> RTable -- ^ input RTable2
-> ETLMapping -- ^ output ETLMapping
createLeafBinETLMapLD etlop rt1 rt2 = ETLMapLD { etlOp = etlop, tabL = rtabToETLMapping rt1, tabR = rt2}
-- | Connects an ETL Mapping to a left-deep ETL Mapping tree, of the form
--
-- @
-- A Left-Deep ETLOperation Tree
--
-- final RTable result
-- /
-- etlOp3
-- / \
-- etlOp2 rtab2
-- / \
-- A leaf-node --> etlOp1 emptyRTab
-- / \
-- ETLMapEmpty rtab1
--
-- @
--
-- Example:
--
-- @
-- -- connect a Unary ETL mapping (etlOp2)
--
-- etlOp2
-- / \
-- etlOp1 emptyRTab
--
-- => connectETLMapLD etlOp2 emptyRTable prevMap
--
-- -- connect a Binary ETL Mapping (etlOp3)
--
-- etlOp3
-- / \
-- etlOp2 rtab2
--
-- => connectETLMapLD etlOp3 rtab2 prevMap
-- @
--
-- Note that the right branch (RTable) appears first in the list of input arguments of this function and
-- the left branch (ETLMapping) appears second. This is strange, and one could thought that it is a mistake
-- (i.e., the left branch should appear first and the right branch second) since we are reading from left to right.
-- However this was a deliberate choice, so that we leave the left branch (which is the connection point with the
-- previous ETLMapping) as the last argument, and thus we can partially apply the argumenets and get a new function
-- with input parameter only the previous mapping. This is very helpfull in function composition
--
connectETLMapLD ::
ETLOperation -- ^ ETL operation of this ETL Mapping
-> RTable -- ^ Right RTable (right branch) (if this is a Unary ETL mapping this should be an emptyRTable)
-> ETLMapping -- ^ Previous ETL mapping (left branch)
-> ETLMapping -- ^ New ETL Mapping, which has added at the end the new node
connectETLMapLD etlop rt prevMap = ETLMapLD { etlOp = etlop, tabL = prevMap, tabR = rt}
-- | This operator executes an 'ETLMapping'
etl = runETLmapping
-- | Executes an 'ETLMapping'
runETLmapping ::
ETLMapping -- ^ input ETLMapping
-> RTable -- ^ output RTable
-- empty ETL mapping
runETLmapping ETLMapEmpty = emptyRTable
-- ETL mapping with an empty ETLOperation, which is just modelling an RTable
runETLmapping ETLMapLD { etlOp = ETLcOp{cmap = ColMapEmpty}, tabL = ETLMapEmpty, tabR = rtab } = rtab
-- leaf node --> unary ETLOperation on RTable
runETLmapping ETLMapLD { etlOp = runMe, tabL = ETLMapEmpty, tabR = rtab } = etlOpU runMe rtab {-- if (isRTabEmpty rtab)
then emptyRTable
else etlOpU runMe rtab --}
runETLmapping ETLMapLD { etlOp = runMe, tabL = prevmap, tabR = rtab } =
if (isRTabEmpty rtab)
then let
prevRtab = runETLmapping prevmap -- execute previous ETLMapping to get the resulting RTable
in etlOpU runMe prevRtab
else let
prevRtab = runETLmapping prevmap -- execute previous ETLMapping to get the resulting RTable
in etlOpB runMe prevRtab rtab
-- | This operator executes an 'ETLMapping' and returns the 'RTabResult' 'Writer' Monad
-- that embedds apart from the resulting RTable, also the number of 'RTuple's returned
etlRes ::
ETLMapping -- ^ input ETLMapping
-> RTabResult -- ^ output RTabResult
etlRes etlm =
let resultRtab = etl etlm
returnedRtups = rtuplesRet $ V.length resultRtab
in rtabResult (resultRtab, returnedRtups)
-- | Model an 'RTable' as an 'ETLMapping' which when executed will return the input 'RTable'
rtabToETLMapping ::
RTable
-> ETLMapping
rtabToETLMapping rt = if (isRTabEmpty rt)
then ETLMapEmpty
else ETLMapLD { etlOp = ETLcOp {cmap = ColMapEmpty}, tabL = ETLMapEmpty, tabR = rt }
--
-- An ETLMapping is implemented as a series of ETLOperations conected with the :=> operator which is right associative
-- i.e., ETLOp3 :=> ETLOp2 :=> ETLOp1 RTable is (ETLOp3 :=> (ETLOp2 :=> (ETLOp1 RTable))
-- infixr 9 :=>
-- data ETLMapping = EmptyETLop RTable | ETLMapping :=> ETLOperation
{--
-- | Executes an ETL mapping
-- Note htat the source RTables are "embedded" in the data constructors of the ETLMapping data type.
runETLmapping ::
ETLMapping -- ^ input ETLMapping
-> RTable -- output RTable
runETLmapping EmptyETLop rtab = rtab
runETLmapping etlMap :=> etlOp = runETLmapping etlMap
case etlOp of
ETLrOp {rop = relOp} -> runROperation relOp
--}
-- Example of an ETLMapping((<T> TabColTransformation).(<F> RPredicate).(<T> TabTransformation) rtable1) `(<EJ> RJoinPredicate)` rtable2
-- ##################################################
-- * Various useful RDataType Transformations
-- * and pre-cooked Column Mappings
-- ##################################################
-- | Returns an ETL Operation that adds a surrogate key column to an RTable
-- The first argument is the initial value of the surrogate key. If Nothing is given, then
-- the initial value will be 0.
-- addSurrogateKey_old :: Integral a =>
-- Maybe a -- ^ The initial value of the Surrogate Key will be the value of this parameter + 1
-- -> a -- ^ Number of rows that the Surrogate Key will be assigned
-- -> ColumnName -- ^ The name of the surrogate key column
-- -> ETLOperation -- ^ Output ETL operation which encapsulates the add surrogate key column mapping
-- addSurrogateKey_old init 0 cname =
-- let initVal = case init of
-- Just x -> x
-- Nothing -> 0
-- cmap = RMap1x1 {
-- srcCol = "", removeSrcCol = No -- the source column can be any column in this mapping, even ""
-- ,trgCol = cname
-- ,transform1x1 = \_ -> RInt (fromIntegral initVal)
-- ,srcRTupleFilter = \_ -> True
-- }
-- in ETLcOp cmap
-- addSurrogateKey_old init numRows cname =
-- let initVal = case init of
-- Just x -> x
-- Nothing -> 0
-- cmap = RMap1x1 {
-- srcCol = "", removeSrcCol = No -- the source column can be any column in this mapping, even ""
-- ,trgCol = cname
-- ,transform1x1 = \_ -> RInt (fromIntegral initVal + 1)
-- ,srcRTupleFilter = \_ -> True
-- }
-- in addSurrogateKey_old (Just (initVal + 1)) (numRows - 1) cname