The ‘Call Log’ SQL Problem

Question

Once again it is time for a Phil Factor Speed Phreak Challenge and the prize is now a $100 Amazon voucher, and the privilege of displaying this rather nice trophy jpg on your blog / website / bedroom wall.

alt text

This time your task is simply to produce a summary report of the cost of international phone calls made within an organization on a week by week basis for both Users and Offices. You are allowed to use any method you see fit, you may also add any indexes, table-functions or views that you wish (though not an index view). Creation of these will not count to the overall execution time. If you are unsure if what you want to do might disqualify you, then please post a comment.

The table CallLog contains the log of every phone call, including which user called which number, when the call started and ended, and the office the user was in at the time. You will notice that it is not well normalized, since it is actually a view taken from several tables. Users are never in a fixed office, and can move from office to office at any point. Calls with a CallEnd equal to CallStart were not answered and can be safely ignored.

To calculate the cost of the call you need to use a lookup within the PhoneTariff table. The calls are prefixed by an area code corresponding to a country.

You must note that many of the call areas have the same starting character sequence , so calls made to numbers starting '35191' must be priced using the tariff of '35191' not '351'.

There is a rather elaborate charging system according to the length of the call. This means that you need to calculate the cost of the call as the minute by minute cost changes with the length of the call. These must be summed.

Looking at the PhoneTariffCharges table

PhoneTariffId UpToXMinutes PricePerMinute
------------- ------------ ---------------------
2865          8            0.4792
2865          31           0.18
2865          59           0.5702
2865          100          1.298

The first 8 minutes of the call will be 0.4792 per minute. 9 to 31 minutes will be 0.18 per minute 32 to 59 minutes will be 0.5702 per minute etc.... All ranges have a UpToXMinutes of 9999 so you dont need to worry about an upper limit. The calllength is rounded upto the nearest whole minute.

Here is the DDL to create the tables

CREATE TABLE [dbo].[CallLog](
    [CallLogId] [int] NOT NULL,
    [CallStart] [datetime] NOT NULL,
    [CallEnd] [datetime] NULL,
    [OfficeName] [varchar](20) NOT NULL,
    [UserName] [varchar](20) NOT NULL,
    [NumberDialled] [varchar](255) NULL
) ON [PRIMARY]

GO



CREATE TABLE [dbo].[PhoneTariff](
    [PhoneTariffId] [int] IDENTITY(1,1) NOT NULL,
    [CallArea] [char](6) NULL,
    [DateStart] [datetime] NULL,
    [DateEnd] [datetime] NULL,
    [HoursStart] [int] NULL,
    [HoursEnd] [int] NULL,
    [ConnectionCharge] [money] NULL
) ON [PRIMARY]

GO


CREATE TABLE [dbo].[PhoneTariffCharges](
    [PhoneTariffId] [int] NULL,
    [UpToXMinutes] [int] NULL,
    [PricePerMinute] [money] NULL
) ON [PRIMARY]

GO

and heres the link to the data. Use

bcp <yourdatabase>..CallLog in CallLog.out -c -E -T
bcp <yourdatabase>..PhoneTariff in PhoneTariff.out -c -E -T
bcp <yourdatabase>..PhoneTariffCharges in PhoneTariffCharges.out -c -E -T

to load the data in.

Heres the solution provided by our mediocre developer Robert Bar, please note a fix for an issue with the week number being taken from @CallEnd.

Drop Table #OfficeTotalByWeek
go
Drop Table #UserTotalByWeek
go

Create Table #OfficeTotalByWeek
(
WeekNo   integer,
Year     integer,
Office   varchar(255),
Total    money
)
go
Create Table #UserTotalByWeek
(
WeekNo   integer,
Year     integer,
UserName     varchar(255),
Total    money
)
go

/*  Routine  : Call Cost Calculate */
/*  Developer : R Bar (RB)            */

 declare @CallStart datetime,
         @CallEnd   datetime,
         @OfficeName varchar(255),
         @UserName   varchar(255),
         @NumberDialled varchar(255),
         @PhoneTariffId integer,
         @ConnectionCharge money,
         @RangeStart       datetime,
         @RangeEnd         datetime

 declare CalcCursor Cursor
 for Select CallStart,CallEnd,OfficeName,UserName,NumberDialled
        from CallLog
    --  where OfficeName = 'Marketing'
        --and UserName  = 'Yolanda Haley'

 open CalcCursor
 while(0=0) begin
    /* RB : For Each Call in CallLog */ 
    fetch next from CalcCursor into @CallStart,@CallEnd,@OfficeName,@UserName,@NumberDialled

    if(@@Fetch_Status <>0)   begin

       break
    end

     if(@CallStart = @CallEnd) begin  /* RB : If True then the call was not answered so no charge */
        continue
     end
    /* RB */
    /* Find the appropriate Tariff */
    /* The number dialled must match the CallArea */
    /* But as the length of the CallArea is variable */
    /* An index seek cannot be used */

    Declare @CallDatech varchar(15)
    Select @CallDatech = CONVERT(varchar(15),@CallStart,112)

    select @PhoneTariffId = NULL
    set rowcount 1
    Select @PhoneTariffID = PhoneTariffId,
           @ConnectionCharge = ConnectionCharge,
           @RangeStart       = DateStart,
           @RangeEnd         = DateEnd
      from phonetariff where @NumberDialled like rtrim(CallArea)+'%' 
       and @CallDateCh between DateStart and DateEnd
       and DatePart(hh,@CallStart) between HoursStart and HoursEnd

    order by len(CallArea) desc   /* RB : Order by is used so the longest CallArea is used */
    set rowcount 0


    if(@PhoneTariffId is null) begin 
        select 'early break out error ',@NumberDialled
    end
    Declare @CallLength integer
    Select @CallLength = ceiling((DATEDIFF(S,@CallStart,@CallEnd))/60.0)

    Declare @RollingBalance money

    Declare @UptoXminutes integer
    Declare @PricePerMinute money
    Declare @MinsThisIter integer

    /* RB : Start the CallCost at the Connection Charge */
    Select @RollingBalance = @ConnectionCharge

    --Select @ConnectionCharge as 'ConnectionCharge' 
    declare @PrevUptoXMinutes integer
    select @PrevUptoXMinutes =0
    Declare TimeCalc Cursor for
    Select UpToXMinutes,PricePerMinute
      from Phonetariffcharges 
     where PhoneTariffId = @PhoneTariffID
    order by UpToXMinutes
    Open timecalc
    /* RB : Now Loop through the minute by minute cost totalling up as we go */
    while(0=0) begin 
       fetch next from timecalc into  @UptoXminutes,@PricePerMinute

       if(@@FETCH_STATUS <>0) begin
          select 'early break out error',@NumberDialled,@PhoneTariffId
          break
       end

       Declare @MinsToIter integer
       /* RB : Calculate how many minutes from this portion we need */
       Select @MinsThisIter = case when @uptoXminutes > @CallLength then @CallLength -@PrevUptoXMinutes
                                                                     else @uptoXminutes -@PrevUptoXMinutes
                                                                     end

       Select @RollingBalance = @RollingBalance +(@MinsThisIter*@PricePerMinute)
       Select @PrevUptoXMinutes = @uptoXminutes 
       if(@uptoXminutes>=@CallLength)begin /* RB : Have we accounted for each minute */
          break
       end

    end
    close TimeCalc
    Deallocate TimeCalc

    if(@PrevUptoXMinutes = 0) begin 
        select 'Charges Calc Error',@NumberDialled,@PhoneTariffId,@CallLength
    end
    Declare @Year integer
    Declare @WeekNo integer
    Select @Year=DATEPART(yy,@CallStart),
           @WeekNo=DATEPART(WEEK,@CallStart)


    /*  RB : Update the Users week-by-week total */
    Update #UserTotalByWeek
       set Total = Total + @RollingBalance
     where UserName =@UserName 
       and WeekNo = @WeekNo
       and Year = @Year
    if(@@ROWCOUNT=0) begin 
       /* RB : Or Create */
       insert into #UserTotalByWeek(UserName,WeekNo,Year,Total)
                          values(@UserName,@WeekNo,@Year,@RollingBalance)
    end
    /* RB : Update the Office week-by-week total */
    Update #OfficeTotalByWeek
       set Total = Total + @RollingBalance
     where Office = @OfficeName
       and WeekNo = @WeekNo
       and Year = @Year
    if(@@ROWCOUNT=0) begin 
       /* RB : Or Create */
       insert into #OfficeTotalByWeek(Office,WeekNo,Year,Total)
                          values(@OfficeName,@WeekNo,@Year,@RollingBalance)
    end    
 end
 close CalcCursor
 Deallocate CalcCursor

 go
 /* RB : Select the totals back */
 Select * from #OfficeTotalByWeek
 Select * from #UserTotalByWeek
 go
 Drop Table #OfficeTotalByWeek
go
Drop Table #UserTotalByWeek
go

Here are some guidelines for your entries:

1) Include a header in your suggestion. Make sure your name and the current date is present.

2) Include an edition number. First edition is 1. If you later improve your current suggestion post it again as version 2. Example: “Peso 1” and if improved, “Peso 1b”, “Peso 1c” etc.

3) If you are trying a new algorithm, change the edition to “Peso 2”. If you improve this algorithm, change the version to “Peso 2b”, “Peso 2c” etc. This will save Phil hours of work in the test harness!

4) The solution must clear up all its mess (temporary tables, indexes, etc.) so it can be re-run without errors.

As ever Phil Factor will be final judge.

The closing date will be midnight Thursday 17th December London

Answer 1

I opted to go no hardwiring at all, because you never know when CallArea changes and suddenly has 6 digits, or more...

First, the Setup part

CREATE
CLUSTERED INDEX CX_PhoneTariff
ON  	dbo.PhoneTariff
    	(
    		CallArea ASC
    	)

CREATE
CLUSTERED INDEX CX_PhoneTariffCharges
ON  	dbo.PhoneTariffCharges
    	(
    		PhoneTariffId ASC,
    		UpToXMinutes ASC
    	)

And then the Teardown part

DROP INDEX CX_PhoneTariff ON dbo.PhoneTariff
DROP INDEX CX_PhoneTariffCharges ON dbo.PhoneTariffCharges

And finally the first version of the query

/*
    Peso 1a, 20091205
*/
DECLARE @PrefixLength INT = (SELECT MAX(LEN(CallArea)) FROM dbo.PhoneTariff)

SELECT  	cl.CallLogId,
    	v.Number AS PrefixLength,
    	cl.OfficeName,
    	cl.UserName,
    	DATEDIFF(DAY, 0, cl.CallStart) AS CallDate,
    	DATEPART(HOUR, cl.CallStart) AS CallHour,
    	LEFT(cl.NumberDialled, v.Number) AS Prefix,
    	CONVERT(INT, CEILING(DATEDIFF(MILLISECOND, cl.CallStart, cl.CallEnd) / 60000.0)) AS CallMinutes
INTO    	#Log
FROM    	dbo.CallLog AS cl WITH (NOLOCK)
INNER JOIN  master..spt_values AS v ON v.Type = 'P'
    		AND v.Number BETWEEN 1 AND @PrefixLength
WHERE   	CONVERT(INT, CEILING(DATEDIFF(MILLISECOND, cl.CallStart, cl.CallEnd) / 60000.0)) > 0
    	AND EXISTS (SELECT * FROM dbo.PhoneTariff AS pt WHERE pt.CallArea = LEFT(cl.NumberDialled, v.Number))
    	--AND cl.OfficeName = 'Marketing'
    	--AND cl.UserName = 'Yolanda Haley'


SELECT  pt.PhoneTariffId,
    DATEDIFF(DAY, 0, pt.DateStart) AS DateStart,
    DATEDIFF(DAY, 0, pt.DateEnd) AS DateEnd,
    pt.HoursStart,
    pt.HoursEnd,
    pt.ConnectionCharge,
    pt.CallArea
INTO    #Tariff
FROM    dbo.PhoneTariff AS pt WITH (NOLOCK)
WHERE   EXISTS(SELECT * FROM #Log AS l WHERE l.Prefix = pt.CallArea AND l.CallHour BETWEEN pt.HoursStart AND pt.HoursEnd)

;WITH Yak(OfficeName, UserName, CallYear, CallWeek, PhoneTariffId, ConnectionCharge, CallMinutes, recID)
AS (
    SELECT		l.OfficeName,
    		l.UserName,
    		DATEPART(YEAR, l.CallDate) AS CallYear,
    		DATEPART(WEEK, l.CallDate) AS CallWeek,
    		t.PhoneTariffId,
    		t.ConnectionCharge,
    		l.CallMinutes,
    		ROW_NUMBER() OVER (PARTITION BY l.CallLogId ORDER BY l.PrefixLength DESC) AS recID
    FROM		#Log AS l
    INNER JOIN	#Tariff AS t ON t.CallArea = l.Prefix
    WHERE		l.CallDate BETWEEN t.DateStart AND t.DateEnd
    		AND l.CallHour BETWEEN t.HoursStart AND t.HoursEnd
)
SELECT  OfficeName,
    UserName,
    CallYear,
    CallWeek,
    PhoneTariffId,
    ConnectionCharge,
    CallMinutes
INTO    #Calls
FROM    Yak
WHERE   recID = 1

DROP TABLE  #Log,
    	#Tariff

SELECT  	ptc.PhoneTariffId,
    	IDENTITY(INT, 1, 1) AS RowID,
    	0 AS FromMinutes,
    	ptc.UpToXMinutes AS ToMinutes,
    	ptc.PricePerMinute
INTO    	#Charges
FROM    	dbo.PhoneTariffCharges AS ptc WITH (NOLOCK)
WHERE   	EXISTS (SELECT * FROM #Calls AS c WHERE c.PhoneTariffID = ptc.PhoneTariffID)
ORDER BY    ptc.PhoneTariffID,
    	ptc.UpToXMinutes

UPDATE  	c
SET 	c.FromMinutes = w.ToMinutes
FROM    	#Charges AS c
INNER JOIN  #Charges AS w ON w.RowID = c.RowID - 1
    		AND w.PhoneTariffID = c.PhoneTariffID
WHERE   	c.PhoneTariffID = w.PhoneTariffID

;WITH Yak(OfficeName, UserName, CallYear, CallWeek, Total)
AS (
    SELECT		c.OfficeName,
    		c.UserName,
    		c.CallYear,
    		c.CallWeek,
    		SUM(CASE WHEN h.FromMinutes = 0 THEN c.ConnectionCharge ELSE 0 END
    			+	CASE
    					WHEN c.CallMinutes >= h.ToMinutes THEN h.ToMinutes - h.FromMinutes
    					WHEN c.CallMinutes >= h.FromMinutes THEN c.CallMinutes - h.FromMinutes
    					ELSE 0
    				END * h.PricePerMinute) AS Total
    FROM		#Calls AS c
    INNER JOIN	#Charges AS h ON h.PhoneTariffId = c.PhoneTariffId
    GROUP BY	c.OfficeName,
    		c.UserName,
    		c.CallYear,
    		c.CallWeek
)
SELECT  OfficeName,
    UserName,
    CallYear,
    CallWeek,
    Total
INTO    #Output
FROM    Yak

DROP TABLE  #Calls,
    	#Charges

SELECT  	OfficeName,
    	CallYear,
    	CallWeek,
    	SUM(Total) AS Total
FROM    	#Output
GROUP BY    OfficeName,
    	CallYear,
    	CallWeek

SELECT  	UserName,
    	CallYear,
    	CallWeek,
    	SUM(Total) AS Total
FROM    	#Output
GROUP BY    UserName,
    	CallYear,
    	CallWeek

DROP TABLE  #Output

Answer 2

Peso 4c - 20091216

CREATE TABLE    #Charges
    	(
    		LineID INT IDENTITY(1, 1) PRIMARY KEY CLUSTERED,
    		CallLogID INT,
    		ConnectionCharge MONEY,
    		PhoneTariffId INT,
    		FromMinute INT,
    		ToMinute INT,
    		PricePerMinute MONEY
    	)

;WITH cteCallArea(Prefix, CallArea)
AS (
    SELECT		u.Prefix,
    		MAX(u.CallArea) AS CallArea
    FROM		(
    			SELECT	d.Prefix,
    				d.Prefix AS Prefix6,
    				CAST(LEFT(d.Prefix, 5) AS CHAR(6)) AS Prefix5,
    				CAST(LEFT(d.Prefix, 4) AS CHAR(6)) AS Prefix4,
    				CAST(LEFT(d.Prefix, 3) AS CHAR(6)) AS Prefix3,
    				CAST(LEFT(d.Prefix, 2) AS CHAR(6)) AS Prefix2,
    				CAST(LEFT(d.Prefix, 1) AS CHAR(6)) AS Prefix1
    			FROM	(
    					SELECT		CAST(NumberDialled AS CHAR(6)) AS Prefix
    					FROM		dbo.CallLog WITH (NOLOCK)
    					WHERE		CallStart < CallEnd
    					GROUP BY	CAST(NumberDialled AS CHAR(6))
    				) AS d
    		) AS l
    UNPIVOT		(
    			CallArea
    			FOR thePrefix IN (l.Prefix6, l.Prefix5, l.Prefix4, l.Prefix3, l.Prefix2, l.Prefix1)
    		) AS u
    INNER JOIN	(
    			SELECT		CallArea
    			FROM		dbo.PhoneTariff WITH (NOLOCK)
    			GROUP BY	CallArea
    		) AS pt ON pt.CallArea = u.CallArea
    GROUP BY	u.Prefix
)
INSERT  	#Charges
    	(
    		CallLogId,
    		PhoneTariffId,
    		ConnectionCharge,
    		FromMinute,
    		ToMinute,
    		PricePerMinute
    	)
SELECT  	cl.CallLogId,
    	ptc.PhoneTariffId,
    	pt.ConnectionCharge,
    	0 AS FromMinute,
    	CASE ptc.UpToXMinutes
    		WHEN f.UpToXMinutes THEN CAST(CEILING(DATEDIFF(SECOND, cl.CallStart, CallEnd) / 60.0) AS INT)
    		ELSE ptc.UpToXMinutes
    	END AS ToMinute,
    	ptc.PricePerMinute
FROM    	dbo.CallLog AS cl WITH (NOLOCK)
INNER JOIN  cteCallArea AS ca ON ca.Prefix = CONVERT(CHAR(6), cl.NumberDialled)
INNER JOIN  dbo.PhoneTariff AS pt WITH (NOLOCK) ON pt.CallArea = ca.CallArea
INNER JOIN  dbo.PhoneTariffCharges AS ptc WITH (NOLOCK) ON ptc.PhoneTariffId = pt.PhoneTariffId
CROSS APPLY (
    		SELECT TOP(1)	x.UpToXMinutes
    		FROM		dbo.PhoneTariffCharges AS x WITH (NOLOCK)
    		WHERE		x.PhoneTariffId = pt.PhoneTariffId
    				AND x.UpToXMinutes >= CAST(CEILING(DATEDIFF(SECOND, cl.CallStart, cl.CallEnd) / 60.0) AS INT)
    		ORDER BY	x.UpToXMinutes
    	) AS f(UpToXMinutes)
WHERE   	cl.CallStart < cl.CallEnd
    	AND DATEDIFF(DAY, 0, cl.CallStart) BETWEEN pt.DateStart AND pt.DateEnd
    	AND DATEPART(HOUR, cl.CallStart) BETWEEN pt.HoursStart AND pt.HoursEnd
    	AND ptc.UpToXMinutes <= f.UpToXMinutes
ORDER BY    cl.CallLogId,
    	ptc.PhoneTariffId,
    	ptc.UpToXMinutes

UPDATE  	c
SET 	c.FromMinute = x.ToMinute
FROM    	#Charges AS c
INNER JOIN  #Charges AS x ON x.LineID = c.LineID - 1
WHERE   	c.CallLogId = x.CallLogId

SELECT  	cl.OfficeName,
    	DATEPART(YEAR, cl.CallStart) AS CallYear,
    	DATEPART(WEEK, cl.CallStart) AS CallWeek,
    	SUM(c.Charge) AS Charge
FROM    	dbo.CallLog AS cl WITH (NOLOCK)
INNER JOIN  (
    		SELECT		CallLogId,
    				SUM(ToMinute * PricePerMinute - FromMinute * PricePerMinute) + MIN(ConnectionCharge) AS Charge
    		FROM		#Charges
    		GROUP BY	CallLogId
    	) AS c ON c.CallLogId = cl.CallLogId
GROUP BY    cl.OfficeName,
    	DATEPART(YEAR, cl.CallStart),
    	DATEPART(WEEK, cl.CallStart)

SELECT  	cl.UserName,
    	DATEPART(YEAR, cl.CallStart) AS CallYear,
    	DATEPART(WEEK, cl.CallStart) AS CallWeek,
    	SUM(c.Charge) AS Charge
FROM    	dbo.CallLog AS cl WITH (NOLOCK)
INNER JOIN  (
    		SELECT		CallLogId,
    				SUM(ToMinute * PricePerMinute - FromMinute * PricePerMinute) + MIN(ConnectionCharge) AS Charge
    		FROM		#Charges
    		GROUP BY	CallLogId
    	) AS c ON c.CallLogId = cl.CallLogId
GROUP BY    cl.UserName,
    	DATEPART(YEAR, cl.CallStart),
    	DATEPART(WEEK, cl.CallStart)

DROP TABLE  #Charges

Answer 3

Phil Factor 1b (1a got mangled by the website because it has < in the code)

This is my first entry, just to show a fairly conventional way of doing it. The call table is redone in a slightly more compute-friendly form. The same is done for the PhoneTariff table. Then the international call prefixes are identified by updating the table progressively, starting with the longest codes first and, at the same time, the PhoneTarrif and the initial connection charge is identified.

Then, the calls are costed out, a charge-band at a time until the longest calls have been costed out.

Once this has been done, then it is a simple matter of aggregating the reports.

I've left my timing harness in place in case you want to tweak the solution, or if you want to see how I generally do it.

On my server, I get times in the 7.5 sec range, for the whole operation. Last time I checked the result was the same as Robert Barr's (bless him)

--start by removing the dead bodies (tables)
IF EXISTS ( SELECT  1
        FROM    tempdb.information_schema.tables
        WHERE   table_name LIKE '#OfficeTotalByWeek%' ) 
DROP TABLE #OfficeTotalByWeek

IF EXISTS ( SELECT  1
        FROM    tempdb.information_schema.tables
        WHERE   table_name LIKE '#PersonTotalByWeek%' ) 
DROP TABLE #PersonTotalByWeek

IF EXISTS ( SELECT  1
        FROM    tempdb.information_schema.tables
        WHERE   table_name LIKE '#Timer%' ) 
DROP TABLE #Timer

IF EXISTS ( SELECT  1
        FROM    tempdb.information_schema.tables
        WHERE   table_name LIKE '#TempCallLog%' ) 
DROP TABLE #TempCalllog

IF EXISTS ( SELECT  1
        FROM    tempdb.information_schema.tables
        WHERE   table_name LIKE '#PhoneTariff%' ) 
DROP TABLE #PhoneTariff

--this is just used for fine-tuning purposes
Create table #timer
(
Timer_ID int identity(1,1),
[event] Varchar(20) not null,
Timepoint datetime not null default Getdate()
)
insert into  #timer([event]) select 'Start'
--create a temporary table to do the costings
SELECT  *,
    CONVERT(INT, NULL) AS phoneTariffID,
    CONVERT(MONEY, 0) AS Connectioncharge,
    CONVERT(MONEY, 0) AS Totalcharge,
    CONVERT(INT, 0) AS CallLengthCosted,
    DATEDIFF(day, 0, CallStart) AS CallStartday,
    DATEPART(hour, CallStart) AS CallStartHour,
    CONVERT(INT, CEILING(DATEDIFF(second, CallStart, callend)/60.00)) AS     CallLengthTotal
INTO    #TempCallLog
FROM    Calllog 

SELECT  *,
    DATEDIFF(day, 0, DateStart) AS DateStartDay,
    DATEDIFF(day, 0, DateEnd) AS DateEndDay
INTO    #phonetariff
FROM    phonetariff
insert into  #timer([event]) select 'Created temp tables'
--this is where we create the indexes. 
CREATE NONCLUSTERED INDEX idxHoursAndDates
ON #TempCallLog ([CallStartDay],[CallStartHour])

CREATE NONCLUSTERED INDEX idxCallHoursAndDates
ON #phonetariff ([DateStartDay],[DateEndDay],[HoursStart],[HoursEnd],[phoneTariffID])

CREATE NONCLUSTERED INDEX idxPhoneTatrrifID 
ON #TempcallLog([phoneTariffID],[NumberDialled],[Connectioncharge],[CallStartday],    [CallStartHour])
insert into  #timer([event]) select 'Created indexes'
--apply the correct five digit area prefix
Update #Tempcalllog set PhoneTariffID=#PhoneTariff.PhoneTariffID,     Connectioncharge=#PhoneTariff.Connectioncharge
from #TempcallLog n inner join #PhoneTariff on CallStartday between DateStartday and DateEndday 
and CallStartHour between hoursStart and HoursEnd
where left(n.numberdialled,5) = callArea and n.PhoneTariffID is null
insert into  #timer([event]) select 'found 5 digit codes'
--apply the correct four digit area prefix
Update #Tempcalllog set PhoneTariffID=#PhoneTariff.PhoneTariffID,     Connectioncharge=#PhoneTariff.Connectioncharge
from #TempcallLog n inner join #PhoneTariff on CallStartday between DateStartday and DateEndday 
and CallStartHour between hoursStart and HoursEnd
where left(n.numberdialled,4) = callArea and n.PhoneTariffID is null
insert into  #timer([event]) select 'found 4 digit codes'
--apply the correct three digit area prefix
Update #Tempcalllog set PhoneTariffID=#PhoneTariff.PhoneTariffID, Connectioncharge=#PhoneTariff.Connectioncharge
from #TempcallLog n inner join #PhoneTariff on CallStartday between DateStartday and DateEndday 
and CallStartHour between hoursStart and HoursEnd
where left(n.numberdialled,3) = callArea and n.PhoneTariffID is null
insert into  #timer([event]) select 'found 3 digit codes'
--apply the correct two digit area prefix
Update #Tempcalllog set PhoneTariffID=#PhoneTariff.PhoneTariffID, Connectioncharge=#PhoneTariff.Connectioncharge
from #TempcallLog n inner join #PhoneTariff on CallStartday between DateStartday and DateEndday 
and CallStartHour between hoursStart and HoursEnd
where left(n.numberdialled,2) = callArea and n.PhoneTariffID is null
insert into  #timer([event]) select 'found 2 digit codes'
--apply the correct one digit area prefix
Update #Tempcalllog set PhoneTariffID=#PhoneTariff.PhoneTariffID,     Connectioncharge=#PhoneTariff.Connectioncharge
from #TempcallLog n inner join #PhoneTariff on CallStartday between DateStartday and DateEndday 
and CallStartHour between hoursStart and HoursEnd
where left(n.numberdialled,1) = callArea and n.PhoneTariffID is null
insert into  #timer([event]) select 'found 1 digit codes'

--put in the initial connectioncharge
Update #Tempcalllog set TotalCharge=ConnectionCharge
where CallLengthTotal>0
insert into  #timer([event]) select 'connection charge'

--and cost out the calls iteratively, but small numbers!
DECLARE @MoreToDo INT
SELECT  @MoreToDo=1 
WHILE @MoreToDo>0
BEGIN

    UPDATE  #Tempcalllog
    SET     CallLengthCosted=CASE WHEN CallLengthTotal<NextBand
                                  THEN CallLengthTotal
                                  ELSE NextBand
                             END,
            TotalCharge=TotalCharge+(PricePerMinute
                                     *(CASE WHEN CallLengthTotal<NextBand
                                            THEN CallLengthTotal-CallLengthCosted
                                            ELSE NextBand-CallLengthCosted
                                       END))

    FROM    #Tempcalllog t
            INNER JOIN (SELECT  CallLogID,
                                MIN(#Tempcalllog.PhoneTariffID) AS PhoneTariffID,
                                MIN(UptoXMinutes) NextBand
                        FROM    #Tempcalllog
                                INNER JOIN PhoneTariffcharges ON PhoneTariffcharges.phonetariffID=#Tempcalllog.phonetariffID
                        WHERE   CallLengthCosted<CallLengthTotal
                                AND UpToXMinutes>CallLengthCosted
                        GROUP BY CallLogID
                       ) ToDo ON todo.CallLogID=t.CallLogID
            INNER JOIN PhoneTariffcharges ON todo.phoneTariffID=PhoneTariffcharges.phoneTariffID
                                             AND     NextBand=PhoneTariffcharges.UptoXMinutes
    SELECT  @MoreToDo=@@Rowcount
    insert into  #timer([event]) select 'Did band '
END

Create Table #OfficeTotalByWeek
(
WeekNo   integer,
Year     integer,
Office   varchar(20),
Total    money
)

insert into #OfficeTotalByWeek
--do the week breakdown by office
SELECT  DATEPART(week, CallStart),
    DATEPART(year, CallStart),
    OfficeName,
    SUM(TotalCharge)
FROM    #Tempcalllog
GROUP BY DATEPART(week, CallStart),
    DATEPART(year, CallStart),
    OfficeName
ORDER BY DATEPART(week, CallStart),
    DATEPART(year, CallStart),
    OfficeName

Create Table #PersonTotalByWeek
(
WeekNo   integer,
Year     integer,
Office   varchar(20),
Total    money
)
insert into  #timer([event]) select 'office grouping '

insert into #PersonTotalByWeek
--do the week breakdown by User
SELECT  DATEPART(week, CallStart),
    DATEPART(year, CallStart),
    UserName,
    SUM(TotalCharge)
FROM    #Tempcalllog
GROUP BY DATEPART(week, CallStart),
    DATEPART(year, CallStart),
    UserName
ORDER BY DATEPART(week, CallStart),
    DATEPART(year, CallStart),
    UserName
insert into  #timer([event]) select 'person grouping '
--SELECT  DATEDIFF(ms, @Timer, GETDATE()) AS [Total time (MS)]

insert into  #timer([event]) select 'End'
Select t.[event],DateDiff (ms,l.timepoint,t.timepoint) 
from #timer t inner join #timer l on t.Timer_ID=l.timer_ID+1
union all
Select 'Total routine ', DateDiff 
(ms, 
(select Timepoint from #timer where event like 'Start'),
(select Timepoint from #timer where event like 'End'))

Answer 4

Here's what I came up with (so far...) In terms of performance I'm in a range of less than 5sec (including output of the results which takes about 0.6 sec). Just to compare: I'm getting approx. 8sec for Phils solution on my PC (thank you for leaving the timing harness in there!).

/*
Phone report
lmu92_1a
*/

/* 
Step 1: adding index to the original table
*/
CREATE CLUSTERED INDEX [CX_CallLog_1] 
    ON [dbo].[CallLog] ([CallLogId],[CallStart],[CallEnd])
CREATE INDEX [IX_CallLog_2] 
    ON [dbo].[CallLog] ([NumberDialled])

CREATE CLUSTERED INDEX [CX_PhoneTariff_1] 
    ON [dbo].[PhoneTariff]([PhoneTariffId])
CREATE INDEX [IX_PhoneTariff_2] 
    ON [dbo].[PhoneTariff]([CallArea])

CREATE CLUSTERED INDEX [CX_PhoneTariffCharges_1] 
    ON [dbo].[PhoneTariffCharges] ([PhoneTariffId])
CREATE INDEX [IX_PhoneTariffCharges_2]
    ON [dbo].[PhoneTariffCharges] ([PhoneTariffId],[UpToXMinutes],[PricePerMinute])

SET nocount ON 

/* 
Step 2: check for temp table to be created and drop if existing
*/

if object_id('tempdb..#callAreaLogID') is not NULL
DROP TABLE #callAreaLogID
if object_id('tempdb..#UserTotalByWeek') is not NULL
DROP TABLE #UserTotalByWeek
if object_id('tempdb..#OfficeTotalByWeek') is not NULL
DROP TABLE #OfficeTotalByWeek

/* 
Step 3: create internal table to hold results based on CallLog.callLogID, but in a format easier to use
*/

CREATE TABLE [dbo].[#callAreaLogID](
    [callLogID] [int] NOT NULL,
    [callArea] [varchar](6) NOT NULL,
    [weekNo] INT NOT NULL,
    [Year] INT NOT NULL,
    [CallStartDay] SMALLDATETIME NOT NULL,
    [CallStartHour] INT NOT NULL,
    [CallDuration] INT NOT NULL,
    [PhoneTariffID] INT  NULL,
    [ConnectionCharge] money  NULL,
    [CallCharge] money  NULL
) ON [PRIMARY]

/* 
Step 4: create final tables as per sample provided

*/
Create Table #OfficeTotalByWeek
(
    WeekNo   integer,
    Year     integer,
    Office   varchar(255),
    Total    money
)

Create Table #UserTotalByWeek
(
    WeekNo   integer,
    Year     integer,
    UserName varchar(255),
    Total    money
)

/*
Step 5: assign the correct area code per call 
    a) get the different CallArea entries from PhoneTariff with a CTE using a simple GROUP BY
    b) to join the "not well normalized"  area codes: join on "NumberDialled LIKE RTRIM(callarea) + '%'" together with a MAX aggregation
    c) to exclude orphaned calls: "WHERE CallStart <> CallEnd"
    d) the CEILING function is used to round the call duration to the next minute 
*/
;
WITH ctePhoneTariffArea AS
(
    SELECT CallArea AS CallArea
    FROM dbo.PhoneTariff
    GROUP BY CallArea
)
INSERT INTO #callAreaLogID (
    [callLogID],
    [callArea],
    [weekNo],
    [Year],
    [CallStartDay], 
    [CallStartHour],
    [CallDuration])
SELECT 
    callLogID,
    RTRIM(max(callArea)) AS  callArea, 
    DATEPART(wk,CallStart) as [weekNo],
    DATEPART(yy,CallStart) as [Year],
    dateadd(dd, datediff(dd, 0, CallStart), 0) AS [CallStartDay],
    DATEPART(hh,CallStart) AS [CallStartHour], 
    CEILING(DATEDIFF(ss,CallStart,CallEnd)/60.0) AS [CallDuration]
FROM CallLog 
    INNER JOIN ctePhoneTariffArea
    ON NumberDialled LIKE  RTRIM(callarea) + '%'
WHERE CallStart <> CallEnd
GROUP BY 
    calllogid,
    DATEPART(wk,CallStart),
    DATEPART(yy,CallStart), 
    DATEADD(dd, DATEDIFF(dd, 0, CallStart), 0) ,
    DATEPART(hh,CallStart), 	
    CEILING(DATEDIFF(ss,CallStart,CallEnd)/60.0) 


/*
Step 6: get the connection charge per call 
*/
UPDATE #callAreaLogID
SET  
    [ConnectionCharge] =t.connectionCharge,
    [PhoneTariffID] = t.PhoneTariffID
FROM #callAreaLogID c 
INNER JOIN dbo.PhoneTariff t
    ON c.callArea = t.callarea
    AND c.[CallStartDay] >= t.DateStart
    AND c.[CallStartDay] <= t.DateEnd
    AND c.[CallStartHour] >= t.HoursStart
    AND c.[CallStartHour] <= t.HoursEnd


/*
Step 7: get the call charge per call using CTEs
 a) cte is used to assign a row number order by UpToXMinutes for each PhoneTariffId
 b) chargeables calculates the relevant minutes to be charged per [UpToXMinutes]  
   Note: the UNION operation is added to add the range from 0 minutes to the first given range
 c) MaxMinutePerCall gets the relevant upper limit for [UpToXMinutes] per call
 d) preSum does the aggregation of call duration costs
   Note: As long as the duration per call is larger than or equal to UpToXMinutes,
     a simple multiplication is done.
     The last portion of the call is calculated based on the remaining minutes within that range
*/
;With cte AS 
(
    SELECT 
    	PhoneTariffId,
    	row_number() OVER (partition BY PhoneTariffId ORDER BY UpToXMinutes) AS row,
    	UpToXMinutes,
    	PricePerMinute
    FROM PhoneTariffCharges
),
chargeables AS
(
    SELECT  
    	cte1.PhoneTariffId, 
    	cte2.uptoxminutes AS Rangestart,
    	cte1.UpToXMinutes,
    	cte1.PricePerMinute,
    	cte1.UpToXMinutes-cte2.UpToXMinutes AS MinutesToCharge 
    FROM cte cte1 
    	INNER JOIN cte cte2
    		ON cte1.PhoneTariffId = cte2.PhoneTariffId
    		AND cte1.row = cte2.row + 1
    UNION ALL
    SELECT
    	cte1.PhoneTariffId, 
    	0,
    	cte1.UpToXMinutes,
    	cte1.PricePerMinute,
    	cte1.UpToXMinutes
    FROM cte cte1 
    WHERE cte1.row=1
),
MaxMinutePerCall AS 
(
    SELECT 
    	t.[callLogID],
    	t.[CallDuration] AS [CallDuration],
    	c.PhoneTariffId,
    	min(UpToXMinutes) AS maxMinutes 
    FROM #callAreaLogID t 
    	INNER JOIN PhoneTariffCharges c
    	ON t.PhoneTariffId = c.PhoneTariffId
    WHERE c.UpToXMinutes >= t.[CallDuration]
    GROUP BY t.[callLogID],[CallDuration],c.PhoneTariffId
)
, 
preSum AS
(
    SELECT 
    m.[callLogID],
    SUM
    (CASE 
    	WHEN callduration >= UpToXMinutes 
    	THEN minutestocharge * PricePerMinute
    	ELSE (Callduration - Rangestart) * PricePerMinute
    	END) AS charge
    FROM chargeables c INNER JOIN MaxMinutePerCall m
    ON c.PhoneTariffId = m.PhoneTariffId
    WHERE c.uptoxminutes <= m.maxMinutes
    GROUP BY m.[callLogID]
)
UPDATE #callAreaLogID
SET #callAreaLogID.CallCharge = p.charge
FROM preSum p INNER JOIN #callAreaLogID t
ON p.callLogID = t.callLogID

/*
Step 8: fill result table #OfficeTotalByWeek
    	Note: to insert the data and display it at the same time the OUTPUT clause is used
*/

INSERT INTO #OfficeTotalByWeek
    OUTPUT 
    	INSERTED.[weekNo], 
    	INSERTED.[year], 
    	INSERTED.Office, 
    	INSERTED.Total
SELECT  
    [weekNo], 
    [year], 
    officename,
    sum(connectioncharge + callcharge)
FROM dbo.CallLog c
    INNER JOIN  #callAreaLogID a
    ON c.CallLogId = a.CallLogId
GROUP BY [weekNo], [year], officename

/*
Step 9: fill result table #UserTotalByWeek
    	Note: to insert the data and display it at the same time the OUTPUT clause is used
*/
INSERT INTO #UserTotalByWeek
    OUTPUT 
    	INSERTED.[weekNo], 
    	INSERTED.[year], 
    	INSERTED.username, 
    	INSERTED.Total
    SELECT	
    [weekNo], 
    [year], 
    username, 
    sum(connectioncharge+callcharge)
FROM dbo.CallLog c
    INNER JOIN  #callAreaLogID a
    ON c.CallLogId = a.CallLogId
GROUP BY [weekNo], [year], username

/*
Step 10: cleanup internal tables
*/
DROP TABLE #callAreaLogID
DROP TABLE #UserTotalByWeek
DROP TABLE #OfficeTotalByWeek

/*
Step 11: cleanup index on base tables
*/
DROP INDEX [CX_CallLog_1] ON [dbo].[CallLog] 
DROP INDEX [IX_CallLog_2] ON [dbo].[CallLog]

DROP INDEX [CX_PhoneTariff_1] ON [dbo].[PhoneTariff]
DROP INDEX [IX_PhoneTariff_2] ON [dbo].[PhoneTariff]

DROP INDEX [CX_PhoneTariffCharges_1] ON [dbo].[PhoneTariffCharges]
DROP INDEX [IX_PhoneTariffCharges_2] ON [dbo].[PhoneTariffCharges]

Answer 5

/*Phil 2b
  running at 4.7 secs on my machine, so not quite up to the leaders yet.*/



 IF EXISTS ( SELECT 1
			 FROM   tempdb.information_schema.tables
			 WHERE  table_name LIKE '#CallIinformation%' ) 
	DROP TABLE #CallIinformation

 IF EXISTS ( SELECT 1
			 FROM   tempdb.information_schema.tables
			 WHERE  table_name LIKE '#TempTotal%' ) 
	DROP TABLE #TempTotal

 IF EXISTS ( SELECT 1
			 FROM   tempdb.information_schema.tables
			 WHERE  table_name LIKE '#PhoneTariff%' ) 
	DROP TABLE #PhoneTariff


 IF EXISTS ( SELECT 1
			 FROM   tempdb.information_schema.tables
			 WHERE  table_name LIKE '#phoneTariffCharges%' ) 
	DROP TABLE #phoneTariffCharges

 CREATE TABLE [dbo].#PhoneTariffCharges
	(
	 [PhoneTariffId] [int] NOT NULL,
	 [UpToXMinutes] [int] NOT NULL,
	 [PricePerMinute] [money] NOT NULL,
	 [orderOfCharge] INT NOT NULL
	)
 ALTER TABLE #phonetariffCharges
 ADD
	PRIMARY KEY (PhoneTariffId, UpToXMinutes) ;

 INSERT INTO #PhoneTariffCharges
		SELECT  PhoneTariffId,
				UpToXMinutes,
				PricePerMinute,
				0
		FROM    PhoneTariffCharges  

 CREATE TABLE [dbo].#PhoneTariff
	(
	 [PhoneTariffId] INT NOT NULL,
	 [CallArea] [char](6) NOT NULL,
	 [DateStart] [datetime] NOT NULL,
	 [DateEnd] [datetime] NOT NULL,
	 [HoursStart] [int] NOT NULL,
	 [HoursEnd] [int] NOT NULL,
	 [ConnectionCharge] [money] NOT NULL,
	 [DateStartDay] [datetime] NOT NULL,
	 [DateEndDay] [datetime] NOT NULL
	) 
 ALTER TABLE #phonetariff
 ADD
	PRIMARY KEY (PhoneTariffId) ;
	--CREATE INDEX idxCallArea ON #PhoneTariff (callarea)

 INSERT INTO #PhoneTariff
		SELECT  PhoneTariffId,
				CallArea,
				DateStart,
				DateEnd,
				HoursStart,
				HoursEnd,
				ConnectionCharge,
				DATEDIFF(day, 0, DateStart) AS DateStartDay,
				DATEDIFF(day, 0, DateEnd) AS DateEndDay
		FROM    phonetariff

 CREATE TABLE #CallIinformation
	(
	 callLogID INT NOT NULL,
	 numberdialled INT NOT NULL,
	 phoneTariffID INT NOT NULL,
	 Connectioncharge MONEY NOT NULL,
	 Totalcharge MONEY NOT NULL,
	 CallLengthCosted INT NOT NULL,
	 CallStartday INT NOT NULL,
	 CallStartHour INT NOT NULL,
	 CallLengthTotal INT NOT NULL,
	 [week] INT NOT NULL,
	 [year] INT NOT NULL
	)
 ALTER TABLE #CallIinformation
 ADD
	PRIMARY KEY (CalllogID)
 INSERT INTO #CallIinformation
		SELECT  callLogID,
				LEFT(numberDialled, 5) AS numberdialled,
				CONVERT(INT, 0) AS phoneTariffID,
				CONVERT(MONEY, 0) AS Connectioncharge,
				CONVERT(MONEY, 0) AS Totalcharge,
				CONVERT(INT, 0) AS CallLengthCosted,
				DATEDIFF(day, 0, CallStart) AS CallStartday,
				DATEPART(hour, CallStart) AS CallStartHour,
				CONVERT(INT, CEILING(DATEDIFF(second, CallStart, callend)
									 /60.00)) AS CallLengthTotal,
				DATEPART(week, CallStart) AS [week],
				DATEPART(year, CallStart) AS [year]
		FROM    Calllog
		WHERE   CallStart<CallEnd
 INSERT INTO #timer ([event])
		SELECT  'stocked table'


	--apply the correct five digit area prefix
 UPDATE #CallIinformation
 SET    PhoneTariffID=#PhoneTariff.PhoneTariffID,
		Connectioncharge=#PhoneTariff.Connectioncharge,
		TotalCharge=#PhoneTariff.Connectioncharge
 FROM   #CallIinformation n
		INNER JOIN #PhoneTariff ON LEFT(n.numberdialled, 5)=callArea
 WHERE  CallStartday BETWEEN DateStartday AND DateEndday
		AND CallStartHour BETWEEN hoursStart AND HoursEnd
	--apply the correct four digit area prefix
 UPDATE #CallIinformation
 SET    PhoneTariffID=#PhoneTariff.PhoneTariffID,
		Connectioncharge=#PhoneTariff.Connectioncharge,
		TotalCharge=#PhoneTariff.Connectioncharge
 FROM   #CallIinformation n
		INNER JOIN #PhoneTariff ON CallStartday BETWEEN DateStartday AND DateEndday
								   AND CallStartHour BETWEEN hoursStart AND HoursEnd
 WHERE  LEFT(n.numberdialled, 4)=callArea
		AND n.PhoneTariffID=0
	--apply the correct three digit area prefix
 UPDATE #CallIinformation
 SET    PhoneTariffID=#PhoneTariff.PhoneTariffID,
		Connectioncharge=#PhoneTariff.Connectioncharge,
		TotalCharge=#PhoneTariff.Connectioncharge
 FROM   #CallIinformation n
		INNER JOIN #PhoneTariff ON CallStartday BETWEEN DateStartday AND DateEndday
								   AND CallStartHour BETWEEN hoursStart AND HoursEnd
 WHERE  LEFT(n.numberdialled, 3)=callArea
		AND n.PhoneTariffID=0
	--apply the correct two digit area prefix
 UPDATE #CallIinformation
 SET    PhoneTariffID=#PhoneTariff.PhoneTariffID,
		Connectioncharge=#PhoneTariff.Connectioncharge,
		TotalCharge=#PhoneTariff.Connectioncharge
 FROM   #CallIinformation n
		INNER JOIN #PhoneTariff ON CallStartday BETWEEN DateStartday AND DateEndday
								   AND CallStartHour BETWEEN hoursStart AND HoursEnd
 WHERE  LEFT(n.numberdialled, 2)=callArea
		AND n.PhoneTariffID=0
	--apply the correct one digit area prefix
 UPDATE #CallIinformation
 SET    PhoneTariffID=#PhoneTariff.PhoneTariffID,
		Connectioncharge=#PhoneTariff.Connectioncharge,
		Totalcharge=#PhoneTariff.Connectioncharge
 FROM   #CallIinformation n
		INNER JOIN #PhoneTariff ON CallStartday BETWEEN DateStartday AND DateEndday
								   AND CallStartHour BETWEEN hoursStart AND HoursEnd
 WHERE  LEFT(n.numberdialled, 1)=callArea
		AND n.PhoneTariffID=0
	--and cost out the calls iteratively, but small numbers!

 DECLARE @orderOfCharge INT
 SELECT @orderOfCharge=0
 DECLARE @PhoneTariffID INT
 UPDATE #PhoneTariffCharges
 SET    @orderOfCharge=orderOfCharge=CASE WHEN @PhoneTariffID<>PhoneTariffID
										  THEN 1
										  ELSE @orderOfCharge+1
									 END,
		@PhoneTariffID=PhoneTariffID

 DECLARE @MoreToDo INT
 DECLARE @ii INT
 SELECT @MoreToDo=1,
		@ii=1
 WHILE @MoreToDo>0
	BEGIN
		UPDATE  #CallIinformation
		SET     CallLengthCosted=CASE WHEN CallLengthTotal<UpToXMinutes
									  THEN CallLengthTotal
									  ELSE UpToXMinutes
								 END,
				TotalCharge=TotalCharge+(PricePerMinute
										 *(CASE WHEN CallLengthTotal<UpToXMinutes
												THEN CallLengthTotal
													 -CallLengthCosted
												ELSE UpToXMinutes
													 -CallLengthCosted
										   END))
		FROM    #CallIinformation t
				INNER JOIN #phoneTariffCharges ON #PhoneTariffcharges.phonetariffID=t.phonetariffID
		WHERE   orderOfCharge=@ii
				AND CallLengthCosted<CallLengthTotal
		SELECT  @MoreToDo=@@Rowcount
		INSERT  INTO #timer ([event])
				SELECT  'Costing '+CONVERT(VARCHAR(5), @ii)
		SELECT  @ii=@ii+1
	END
 CREATE TABLE #temptotal
	(
	 Officename VARCHAR(20) NOT NULL,
	 Username VARCHAR(20) NOT NULL,
	 Year INTEGER NOT NULL,
	 Week INTEGER NOT NULL,
	 Totalcharge MONEY NOT NULL,

	)
 ALTER TABLE #temptotal
 ADD
	PRIMARY KEY (year, week, officename, username)
 INSERT INTO #temptotal
		SELECT  officename,
				username,
				year,
				week,
				SUM(Totalcharge) AS totalcharge
		FROM    #CallIinformation
				INNER JOIN CallLog ON #CallIinformation.callLogID=CallLog.calllogID
		GROUP BY week,
				year,
				OfficeName,
				Username          


	--do the week breakdown by office
 SELECT week,
		year,
		OfficeName,
		SUM(TotalCharge)
 FROM   #temptotal
 GROUP BY week,
		year,
		OfficeName


	--do the week breakdown by User
 SELECT week,
		year,
		UserName,
		SUM(TotalCharge)
 FROM   #temptotal
 GROUP BY week,
		year,
		UserName

The ‘Call Log’ SQL Problem

Follow this question

Related Questions