Throw away your pocket calculators; visit www.calcResult.com

--insert prime numbers into Primes
INSERT INTO [dbo].[Primes](p)
SELECT s1.seq AS PrimeNumbers
FROM [dbo].[Sequence] s1
WHERE
	(s1.seq > 1 AND s1.seq < 10000)
	AND (s1.seq % 2 = 1 or s1.seq=2)
	AND NOT EXISTS(
		SELECT 1
		FROM [dbo].[Sequence] s2
		WHERE 
			(s2.seq < s1.seq AND s2.seq > 1)
			AND s1.seq % s2.seq = 0		
		)

DECLARE @Primes TABLE(p INT NOT NULL)
DECLARE @Sequence TABLE(seq INT NOT NULL)
DECLARE @Digits TABLE(i INT NOT NULL)
DECLARE @RemoveTable TABLE(i INT)

DECLARE @limit INT; SET @limit = 1000

--load up digits per provided filling mechanism
INSERT INTO @Digits VALUES(1)
INSERT INTO @Digits VALUES(2)
INSERT INTO @Digits VALUES(3)
INSERT INTO @Digits VALUES(4)
INSERT INTO @Digits VALUES(5)
INSERT INTO @Digits VALUES(6)
INSERT INTO @Digits VALUES(7)
INSERT INTO @Digits VALUES(8)
INSERT INTO @Digits VALUES(9)
INSERT INTO @Digits VALUES(0)

--add to sequence table per provided filling mechanism
INSERT INTO @Sequence
SELECT (D3.i * 1000 + D2.i * 100 + D1.i * 10 + D0.i + 1) AS seq
    FROM @Digits AS D0, @Digits AS D1, @Digits AS D2, @Digits AS D3

--add non prime numbers to remove table.  This uses a cartesian join, restricting on:
--		1. joining on matching values
--		2. joined table value less than left table value
--		3. values less than pre-defined limit and greater than or equal to zero
--		4. left table mod right table = 0
--
--Distinct values are returned

INSERT INTO @RemoveTable
	SELECT DISTINCT S1.seq 
	FROM @Sequence S1, @Sequence S2
	WHERE S1.seq <> S2.seq
		AND S2.seq < s1.[seq]
		AND S1.seq BETWEEN 2 AND @limit
		AND S2.seq BETWEEN 2 AND @limit - 1
		AND S1.seq % S2.seq = 0
			

SELECT seq FROM @Sequence
WHERE seq BETWEEN 2 AND  @limit
	AND seq NOT IN
	(
		SELECT i FROM @RemoveTable
	)
ORDER BY seq

----------------
-- solution #1
----------------

--clear primes table
delete from Primes

-- add all numbers
insert into Primes (p)
select	seq
from	Sequence
where	seq > 1

-- delete non-primes
delete	p
from	Primes p
where	p.p in 	(
		-- get numbers that are non-primes
		select	s1.seq
		from	Sequence s1
		where	exists	(
				-- see if s1.seq is evenly divisible by a lower number (non-primes)
				select	*
				from	Sequence s2
				where	s2.seq between 2 and (s1.seq / 2)
				and	s1.seq % s2.seq = 0
				)
		)

-- return primes
select	p
from	Primes p
order by p.p

----------------
-- solution #2
----------------

--clear primes table
delete from Primes

-- insert primes
insert into Primes (p)
select	s1.seq
from	Sequence s1
where	s1.seq	> 1	-- prime must be > 1
and	not exists	(
			-- get numbers that are evenly divisible by a lower number (non-primes)
			select	*
			from	Sequence s2
			where	s2.seq between 2 and (s1.seq / 2)
			and	s1.seq % s2.seq = 0
			)

-- return primes
select	p
from	Primes p
order by p.p

DECLARE @START AS DATETIME, @END AS DATETIME
SET @START = GETDATE()

DECLARE @PRIMES TABLE (
	PRIME INT NOT NULL PRIMARY KEY CLUSTERED
)
DECLARE @NUMS TABLE (
	N INT NOT NULL PRIMARY KEY CLUSTERED,
	CN AS (RIGHT(CAST(N AS varchar(10)),1)) PERSISTED,
	SR AS CAST(CEILING(SQRT(N)) AS INT) PERSISTED
)
INSERT INTO @NUMS(N)
SELECT N
FROM master.dbo.Tally
WHERE N > 6 AND
	RIGHT(CAST(N AS varchar(10)),1) IN ('1','3','7','9') AND
	N % 6 IN (1, 5)

INSERT INTO @PRIMES(PRIME)
	SELECT CAST(2 AS INT) AS PRIME
	UNION ALL
	SELECT CAST(3 AS INT)
	UNION ALL
	SELECT CAST(5 AS INT)
	UNION ALL
	SELECT N1.N
	FROM @NUMS AS N1
	WHERE NOT EXISTS ( SELECT 1 FROM master.dbo.Tally AS N2 WHERE N2.N > 1 AND N2.N <= N1.SR AND N1.N % N2.N = 0 )

SELECT *
FROM @PRIMES

SET @END = GETDATE()
PRINT 'Total Duration: ' + CAST(CAST(DATEDIFF(ms, @START, @END)/1000. AS decimal(7,3)) AS varchar(15)) + ' seconds'

DECLARE @MAXLIMIT int DECLARE @LIMIT int
SET              @LIMIT = 1000
 /* What is the biggest prime number we can find from the current factors table*/ 
SELECT @MAXLIMIT = MAX(f) * MAX(f)
FROM         Factors
/* If we need bigger factors, add prime numbers up to the square of our current largest factor*/
WHILE @MAXLIMIT < @LIMIT
BEGIN
      INSERT      
      INTO            Factors(f)
           SELECT     6 * Sequence.seq + S.S AS f
           FROM         Sequence CROSS JOIN
                              (SELECT     S   FROM          Switch) AS S
          WHERE     (6 * Sequence.seq + 1 <= @MAXLIMIT)
          AND (0 NOT IN (SELECT     (6 * Sequence.seq + S.S) % f AS FactorialTest
                                    FROM          Factors))
          /* What is the biggest prime number we can find from the current factors table*/
          SELECT @MAXLIMIT = MAX(f) * MAX(f)
          FROM         Factors 
END

/* Insert the factors table into Primes and add the remaining primes less than @Limit*/
INSERT  
INTO            Primes(p)
   SELECT F FROM Factors
UNION
   SELECT     6 * Sequence.seq + S.S AS f
   FROM         Sequence CROSS JOIN
                     (SELECT     S FROM          Switch) AS S
  WHERE     (6 * Sequence.seq + 1 <= @LIMIT)
   AND (0 NOT IN (SELECT     (6 * Sequence.seq + S.S) % f AS FactorialTest
                              FROM          Factors))

CREATE TABLE [tbl_Numbers] ( 
	Number int NOT NULL CONSTRAINT pkNumbers_Number_UC PRIMARY KEY CLUSTERED (Number)
) 
GO

SELECT
    *
FROM
    tbl_Numbers
EXCEPT
SELECT
    candidate.Number
FROM
    tbl_Numbers AS candidate
    CROSS JOIN tbl_Numbers AS factor
WHERE
    factor.Number < candidate.Number
    AND factor.Number > 1
    AND candidate.Number % factor.Number = 0