|
|
And finally I get to see them live after 3 years; not only that, but this time around they are the opening act for another band. A band from across the pond. A band call IRON MAIDEN!!!!!!
Here are the press releases from both Dream Theater & Iron Maiden’s sites:
http://dreamtheater.net/news_dreamtheater.php#dtmaiden
http://www.ironmaiden.com/index.php?categoryid=8&p2_articleid=1183
Tickets go on sale to the public on 3/20/2010 & 3/13/2010 for Iron Maiden fan club members. Guess what? I am a proud new member of the Iron Maiden fan club as of 5 minutes ago. I have not been this excited since DT announced the release of BCSL 
Here are the rest of the US Tour Dates:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| **THE FINAL FRONTIER 2010 NORTH AMERICAN TOUR**
JUNE
Wed 09 Dallas,TX Superpages.com Center
Fri 11 Houston,TX Cynthia Woods Mitchell Pavilion
Sat 12 San Antonio,TX AT&T Center
Mon 14 Denver,CO Comfort Dental Amphitheatre
Wed 16 Albuquerque,NM The Pavilion
Thu 17 Phoenix,AZ Cricket Wireless Pavilion
Sat 19 San Bernardino,CA San Manuel Amphitheatre
Sun 20 Concord,CA Sleep Train Pavilion
Tue 22 Auburn,WA White River Amphitheatre
Thu 24 Vancouver,BC GM Place
Sat 26 Edmonton,AB Rexall Place
Tue 29 Saskatoon,SK Credit Union Centre
Wed 30 Winnipeg,MB MTSCentre+
JULY
Sat 03 Toronto,ON Molson Amphitheatre
Wed 07 Montreal,QC Bell Centre*
Sun 11 Holmdel,NJ PNC
Mon 12 New York,NY Madison Square Garden++
Wed 14 Pittsburgh,PA First Niagara Pavilion
Thu 15 Cleveland,OH Blossom Music Center
Sat 17 Detroit,MI DTE Energy Music Theatre
Sun 18 Chicago,IL First Midwest Bank Amphitheatre
Tue 20 Washington D.C. Jiffy Lube Live |
 Share on Facebook
…or the newly Microsoft SQL DBA converted to Oracle by proxy. I think I may be posting quite a few of these in the upcoming days while I slowly move deeper into Oracle DBA territory. The learning curve will be steep, but hope it will be a rewarding trip. Enough nonsense though. Here we go.
Comparing Microsoft SQL 200x vs Oracle 11g
http://www.psoug.org/reference/sqlserver.html
Priceless! Quite possibly the holy grail of guides out there in helping us understand the basic differences with Oracle.
Migrating hard to -or impossible to- convert data types from SQL to Oracle
http://www.oracle.com/technology/obe/hol08/sqldev_migration/mssqlserver/migrate_microsoft_sqlserver_otn.htm
Credit goes out to my boss for finding this while I was treading water trying to figure out how to pump data from a SQL2005 [text] data type to an Oracle [CLOB] column across a linked server using Openquery. The method presented by Oracle is far more complex and lenghty but it works.
More to come on the next days…
http://www.techonthenet.com/oracle/index.php
Listing all the schemas, schema owners, database & instance name
1
2
3
4
5
6
| with get_schemas as(
select distinct owner
from dba_objects
)
select name db_name, instance_name, owner
from v$instance, v$database, get_schemas; |
Share on Facebook
I’ve been asked all too often to forecast database storage growth over time. The cookie-cutter way to do it is tedious: monitor data file growth blindly over a period of time and derive gross growth from it. I, instead, prefer a more detailed approach which allows me to look not only at the overall space footprint of my database, but also at the space being used on a per-row basis, space used by indexes, and slack that might be pre-allocated and actually saved. I dabbed on using [sp_spaceused], which if I am not mistaken is available from SQL 2000 forward. But I wanted something a little more ‘hands-free’, so I came up with the following implementation which creates a temporary table that can easily be turned into a permanent table instead. This small CURSOR-based script can easily be modified to log table space utilization over time and allow for a far more educated ‘guess’ on how much more drive space your application will need over time. So, here it is, another one of my handy-dandy SQL scripts:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| CREATE TABLE #tblSpace (name varchar(50),numRows int,txtReserved varchar(50),txtData varchar(50),txtIndexSize varchar(50),txtUnused varchar(50))
DECLARE @SQL AS VARCHAR(500)
DECLARE @tablename sysname
DECLARE tables_cursor CURSOR
FOR
SELECT '['+CONVERT(varchar(30),Name)+']' AS TableName
FROM sysobjects WITH (NOLOCK)
WHERE Type = 'U'
ORDER BY TableName
OPEN tables_cursor
FETCH NEXT FROM tables_cursor INTO @tablename
WHILE (@@FETCH_STATUS <> -1)
BEGIN
SET @SQL = 'INSERT INTO #tblSpace (name,numRows,txtReserved,txtData,txtIndexSize,txtUnused) EXEC sp_spaceused ' + @tablename
EXEC (@SQL)
FETCH NEXT FROM tables_cursor INTO @tablename
END
CLOSE tables_cursor
DEALLOCATE tables_cursor
SELECT* FROM #tblSpace ORDER BY name
DROP TABLE #tblSpace |
Share on Facebook
It’s time to put all the pieces together and create a simple way to take a look at all the memberships & roles which exist across all our databases. Like I mentioned before, this might be very useful whenever an internal audit comes through and we are asked to produce a report: who, what, where & when (just ‘Ws’ here, no ‘How’).
- Who has access?
- What access level ‘who’ has to our databases?
- Where does ‘Who’ has a ‘What’ access?
- When did ‘Who’ gain ‘What’ access to our databases?
Makes sense?
Let’s cut to the chase. Here is the script. Go ahead, execute it on your test server and see if you like it, change it, sell it, I don’t care. Just let me know if you find it useful or have any comments.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
| CREATE TABLE #DBRolesAndMembers (
dbname VARCHAR(50),
role_principal_id INT,
member_principal_id INT,
role_type_desc VARCHAR(50),
role_name VARCHAR(50),
member_name VARCHAR(50),
create_date DATETIME,
modify_date DATETIME
)
GO
DECLARE @DBNAME AS VARCHAR(50)
DECLARE MyCursor CURSOR
FOR SELECT [name] FROM sys.databases WHERE state = 0
OPEN MyCursor
FETCH NEXT FROM MyCursor INTO @DBNAME
WHILE @@FETCH_STATUS = 0
BEGIN
DECLARE @SQL as varchar(max)
set @sql = '
INSERT INTO #DBRolesAndMembers
SELECT
'''+@DBNAME+''' as ''dbname'',
drm.role_principal_id,
drm.member_principal_id,
dp.name as ''role_name'',
dp.type_desc as ''role_type_desc'',
dpu.name as ''member_name'',
dpu.create_date as ''member_create_date'',
dpu.modify_date as ''member_modify_date''
FROM
'+@DBNAME+'.sys.database_role_members as drm
RIGHT JOIN '+@DBNAME+'.sys.database_principals as dp
ON dp.principal_id = drm.role_principal_id
RIGHT JOIN '+@DBNAME+'.sys.database_principals as dpu
ON dpu.principal_id = drm.member_principal_id
WHERE
drm.role_principal_id IS NOT NULL
AND drm.member_principal_id IS NOT NULL'
exec (@sql)
FETCH NEXT FROM MyCursor INTO @DBNAME
END
CLOSE MyCursor
DEALLOCATE MyCursor
SELECT * FROM #DBRolesAndMembers
drop table #DBRolesAndMembers |
Share on Facebook
On our previous article we briefly touched on database roles and what they are, but more importantly, we started to talk about database principals. A database principal is essentially any entity or object that can request SQL Server resources. So what entities are grouped under the principal ‘moniker’? Anythig from database roles downright to database users.
For instance, if we take a look at the list of principals on a [master] database, we might see a listing like this. And if we look under [name] we see that the first value corresponds to [public]; [public] is a database_level role -there is also a certificate mapped user. But why bag roles & users together, if a user can be a member of one or more roles? Because resources can be controlled at database user and role levels alike, both offering varying grades of granularity.
 - sys.database_principals
The column definitions offered on the previous article should be rather self explanatory now that you can see actual data. Go ahead, query against one of your database’s sys.database_principals admin view and then compare it to what you see through SQL Server Management Studio for the same database.
Now, the next step in our quest is to figure out what kind of memberships exist for our principal / users -which groups do users belong to? Pretty easy! There is obviously another management view which exposes that information (think of it this way from here on: anything that’s done through SSMS, can be replicated by transact-sql means). In our case, principal-users and role relations are exposed through: sys.database_role_members.
1
| SELECT * FROM sys.database_role_members |
This view will expose the principal_id of the role matched against the principal_id of a user or other entity belonging to a role. And we will see how to exploit this very easily on the next article -I am tired & cranky right now.
Share on Facebook
|
|
