diff options
Diffstat (limited to 'OpenSim/Data')
57 files changed, 6148 insertions, 0 deletions
diff --git a/OpenSim/Data/SQLiteNG/Properties/AssemblyInfo.cs b/OpenSim/Data/SQLiteNG/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..d45ab50 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Properties/AssemblyInfo.cs | |||
@@ -0,0 +1,65 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System.Reflection; | ||
29 | using System.Runtime.InteropServices; | ||
30 | |||
31 | // General information about an assembly is controlled through the following | ||
32 | // set of attributes. Change these attribute values to modify the information | ||
33 | // associated with an assembly. | ||
34 | |||
35 | [assembly : AssemblyTitle("OpenSim.Data.SQLite")] | ||
36 | [assembly : AssemblyDescription("")] | ||
37 | [assembly : AssemblyConfiguration("")] | ||
38 | [assembly : AssemblyCompany("http://opensimulator.org")] | ||
39 | [assembly : AssemblyProduct("OpenSim.Data.SQLite")] | ||
40 | [assembly : AssemblyCopyright("Copyright (c) OpenSimulator.org Developers 2007-2009")] | ||
41 | [assembly : AssemblyTrademark("")] | ||
42 | [assembly : AssemblyCulture("")] | ||
43 | |||
44 | // Setting ComVisible to false makes the types in this assembly not visible | ||
45 | // to COM components. If you need to access a type in this assembly from | ||
46 | // COM, set the ComVisible attribute to true on that type. | ||
47 | |||
48 | [assembly : ComVisible(false)] | ||
49 | |||
50 | // The following GUID is for the ID of the typelib if this project is exposed to COM | ||
51 | |||
52 | [assembly : Guid("6113d5ce-4547-49f4-9236-0dcc503457b1")] | ||
53 | |||
54 | // Version information for an assembly consists of the following four values: | ||
55 | // | ||
56 | // Major Version | ||
57 | // Minor Version | ||
58 | // Build Number | ||
59 | // Revision | ||
60 | // | ||
61 | // You can specify all the values or you can default the Revision and Build Numbers | ||
62 | // by using the '*' as shown below: | ||
63 | |||
64 | [assembly : AssemblyVersion("0.6.5.*")] | ||
65 | [assembly : AssemblyFileVersion("0.6.5.0")] | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/001_AssetStore.sql b/OpenSim/Data/SQLiteNG/Resources/001_AssetStore.sql new file mode 100644 index 0000000..2e026ca --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/001_AssetStore.sql | |||
@@ -0,0 +1,12 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | CREATE TABLE assets( | ||
3 | UUID varchar(255) primary key, | ||
4 | Name varchar(255), | ||
5 | Description varchar(255), | ||
6 | Type integer, | ||
7 | InvType integer, | ||
8 | Local integer, | ||
9 | Temporary integer, | ||
10 | Data blob); | ||
11 | |||
12 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/001_AuthStore.sql b/OpenSim/Data/SQLiteNG/Resources/001_AuthStore.sql new file mode 100644 index 0000000..468567d --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/001_AuthStore.sql | |||
@@ -0,0 +1,18 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | CREATE TABLE auth ( | ||
4 | UUID char(36) NOT NULL, | ||
5 | passwordHash char(32) NOT NULL default '', | ||
6 | passwordSalt char(32) NOT NULL default '', | ||
7 | webLoginKey varchar(255) NOT NULL default '', | ||
8 | accountType VARCHAR(32) NOT NULL DEFAULT 'UserAccount', | ||
9 | PRIMARY KEY (`UUID`) | ||
10 | ); | ||
11 | |||
12 | CREATE TABLE tokens ( | ||
13 | UUID char(36) NOT NULL, | ||
14 | token varchar(255) NOT NULL, | ||
15 | validity datetime NOT NULL | ||
16 | ); | ||
17 | |||
18 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/001_Avatar.sql b/OpenSim/Data/SQLiteNG/Resources/001_Avatar.sql new file mode 100644 index 0000000..7ec906b --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/001_Avatar.sql | |||
@@ -0,0 +1,9 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | CREATE TABLE Avatars ( | ||
4 | PrincipalID CHAR(36) NOT NULL, | ||
5 | Name VARCHAR(32) NOT NULL, | ||
6 | Value VARCHAR(255) NOT NULL DEFAULT '', | ||
7 | PRIMARY KEY(PrincipalID, Name)); | ||
8 | |||
9 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/001_FriendsStore.sql b/OpenSim/Data/SQLiteNG/Resources/001_FriendsStore.sql new file mode 100644 index 0000000..f1b9ab9 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/001_FriendsStore.sql | |||
@@ -0,0 +1,10 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | CREATE TABLE `Friends` ( | ||
4 | `PrincipalID` CHAR(36) NOT NULL, | ||
5 | `Friend` VARCHAR(255) NOT NULL, | ||
6 | `Flags` VARCHAR(16) NOT NULL DEFAULT 0, | ||
7 | `Offered` VARCHAR(32) NOT NULL DEFAULT 0, | ||
8 | PRIMARY KEY(`PrincipalID`, `Friend`)); | ||
9 | |||
10 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/001_InventoryStore.sql b/OpenSim/Data/SQLiteNG/Resources/001_InventoryStore.sql new file mode 100644 index 0000000..554d5c2 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/001_InventoryStore.sql | |||
@@ -0,0 +1,32 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | CREATE TABLE inventoryfolders( | ||
4 | UUID varchar(255) primary key, | ||
5 | name varchar(255), | ||
6 | agentID varchar(255), | ||
7 | parentID varchar(255), | ||
8 | type integer, | ||
9 | version integer); | ||
10 | |||
11 | CREATE TABLE inventoryitems( | ||
12 | UUID varchar(255) primary key, | ||
13 | assetID varchar(255), | ||
14 | assetType integer, | ||
15 | invType integer, | ||
16 | parentFolderID varchar(255), | ||
17 | avatarID varchar(255), | ||
18 | creatorsID varchar(255), | ||
19 | inventoryName varchar(255), | ||
20 | inventoryDescription varchar(255), | ||
21 | inventoryNextPermissions integer, | ||
22 | inventoryCurrentPermissions integer, | ||
23 | inventoryBasePermissions integer, | ||
24 | inventoryEveryOnePermissions integer, | ||
25 | salePrice integer default 99, | ||
26 | saleType integer default 0, | ||
27 | creationDate integer default 2000, | ||
28 | groupID varchar(255) default '00000000-0000-0000-0000-000000000000', | ||
29 | groupOwned integer default 0, | ||
30 | flags integer default 0); | ||
31 | |||
32 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/001_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/001_RegionStore.sql new file mode 100644 index 0000000..39e8180 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/001_RegionStore.sql | |||
@@ -0,0 +1,144 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | CREATE TABLE prims( | ||
4 | UUID varchar(255) primary key, | ||
5 | RegionUUID varchar(255), | ||
6 | ParentID integer, | ||
7 | CreationDate integer, | ||
8 | Name varchar(255), | ||
9 | SceneGroupID varchar(255), | ||
10 | Text varchar(255), | ||
11 | Description varchar(255), | ||
12 | SitName varchar(255), | ||
13 | TouchName varchar(255), | ||
14 | CreatorID varchar(255), | ||
15 | OwnerID varchar(255), | ||
16 | GroupID varchar(255), | ||
17 | LastOwnerID varchar(255), | ||
18 | OwnerMask integer, | ||
19 | NextOwnerMask integer, | ||
20 | GroupMask integer, | ||
21 | EveryoneMask integer, | ||
22 | BaseMask integer, | ||
23 | PositionX float, | ||
24 | PositionY float, | ||
25 | PositionZ float, | ||
26 | GroupPositionX float, | ||
27 | GroupPositionY float, | ||
28 | GroupPositionZ float, | ||
29 | VelocityX float, | ||
30 | VelocityY float, | ||
31 | VelocityZ float, | ||
32 | AngularVelocityX float, | ||
33 | AngularVelocityY float, | ||
34 | AngularVelocityZ float, | ||
35 | AccelerationX float, | ||
36 | AccelerationY float, | ||
37 | AccelerationZ float, | ||
38 | RotationX float, | ||
39 | RotationY float, | ||
40 | RotationZ float, | ||
41 | RotationW float, | ||
42 | ObjectFlags integer, | ||
43 | SitTargetOffsetX float NOT NULL default 0, | ||
44 | SitTargetOffsetY float NOT NULL default 0, | ||
45 | SitTargetOffsetZ float NOT NULL default 0, | ||
46 | SitTargetOrientW float NOT NULL default 0, | ||
47 | SitTargetOrientX float NOT NULL default 0, | ||
48 | SitTargetOrientY float NOT NULL default 0, | ||
49 | SitTargetOrientZ float NOT NULL default 0); | ||
50 | |||
51 | CREATE TABLE primshapes( | ||
52 | UUID varchar(255) primary key, | ||
53 | Shape integer, | ||
54 | ScaleX float, | ||
55 | ScaleY float, | ||
56 | ScaleZ float, | ||
57 | PCode integer, | ||
58 | PathBegin integer, | ||
59 | PathEnd integer, | ||
60 | PathScaleX integer, | ||
61 | PathScaleY integer, | ||
62 | PathShearX integer, | ||
63 | PathShearY integer, | ||
64 | PathSkew integer, | ||
65 | PathCurve integer, | ||
66 | PathRadiusOffset integer, | ||
67 | PathRevolutions integer, | ||
68 | PathTaperX integer, | ||
69 | PathTaperY integer, | ||
70 | PathTwist integer, | ||
71 | PathTwistBegin integer, | ||
72 | ProfileBegin integer, | ||
73 | ProfileEnd integer, | ||
74 | ProfileCurve integer, | ||
75 | ProfileHollow integer, | ||
76 | Texture blob, | ||
77 | ExtraParams blob, | ||
78 | State Integer NOT NULL default 0); | ||
79 | |||
80 | CREATE TABLE primitems( | ||
81 | itemID varchar(255) primary key, | ||
82 | primID varchar(255), | ||
83 | assetID varchar(255), | ||
84 | parentFolderID varchar(255), | ||
85 | invType integer, | ||
86 | assetType integer, | ||
87 | name varchar(255), | ||
88 | description varchar(255), | ||
89 | creationDate integer, | ||
90 | creatorID varchar(255), | ||
91 | ownerID varchar(255), | ||
92 | lastOwnerID varchar(255), | ||
93 | groupID varchar(255), | ||
94 | nextPermissions string, | ||
95 | currentPermissions string, | ||
96 | basePermissions string, | ||
97 | everyonePermissions string, | ||
98 | groupPermissions string); | ||
99 | |||
100 | CREATE TABLE terrain( | ||
101 | RegionUUID varchar(255), | ||
102 | Revision integer, | ||
103 | Heightfield blob); | ||
104 | |||
105 | CREATE TABLE land( | ||
106 | UUID varchar(255) primary key, | ||
107 | RegionUUID varchar(255), | ||
108 | LocalLandID string, | ||
109 | Bitmap blob, | ||
110 | Name varchar(255), | ||
111 | Desc varchar(255), | ||
112 | OwnerUUID varchar(255), | ||
113 | IsGroupOwned string, | ||
114 | Area integer, | ||
115 | AuctionID integer, | ||
116 | Category integer, | ||
117 | ClaimDate integer, | ||
118 | ClaimPrice integer, | ||
119 | GroupUUID varchar(255), | ||
120 | SalePrice integer, | ||
121 | LandStatus integer, | ||
122 | LandFlags string, | ||
123 | LandingType string, | ||
124 | MediaAutoScale string, | ||
125 | MediaTextureUUID varchar(255), | ||
126 | MediaURL varchar(255), | ||
127 | MusicURL varchar(255), | ||
128 | PassHours float, | ||
129 | PassPrice string, | ||
130 | SnapshotUUID varchar(255), | ||
131 | UserLocationX float, | ||
132 | UserLocationY float, | ||
133 | UserLocationZ float, | ||
134 | UserLookAtX float, | ||
135 | UserLookAtY float, | ||
136 | UserLookAtZ float, | ||
137 | AuthbuyerID varchar(36) NOT NULL default '00000000-0000-0000-0000-000000000000'); | ||
138 | |||
139 | CREATE TABLE landaccesslist( | ||
140 | LandUUID varchar(255), | ||
141 | AccessUUID varchar(255), | ||
142 | Flags string); | ||
143 | |||
144 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/001_UserAccount.sql b/OpenSim/Data/SQLiteNG/Resources/001_UserAccount.sql new file mode 100644 index 0000000..c38d9a7 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/001_UserAccount.sql | |||
@@ -0,0 +1,17 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | -- useraccounts table | ||
4 | CREATE TABLE UserAccounts ( | ||
5 | PrincipalID CHAR(36) primary key, | ||
6 | ScopeID CHAR(36) NOT NULL, | ||
7 | FirstName VARCHAR(64) NOT NULL, | ||
8 | LastName VARCHAR(64) NOT NULL, | ||
9 | Email VARCHAR(64), | ||
10 | ServiceURLs TEXT, | ||
11 | Created INT(11), | ||
12 | UserLevel integer NOT NULL DEFAULT 0, | ||
13 | UserFlags integer NOT NULL DEFAULT 0, | ||
14 | UserTitle varchar(64) NOT NULL DEFAULT '' | ||
15 | ); | ||
16 | |||
17 | COMMIT; \ No newline at end of file | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/001_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/001_UserStore.sql new file mode 100644 index 0000000..b584594 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/001_UserStore.sql | |||
@@ -0,0 +1,39 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | -- users table | ||
4 | CREATE TABLE users( | ||
5 | UUID varchar(255) primary key, | ||
6 | username varchar(255), | ||
7 | surname varchar(255), | ||
8 | passwordHash varchar(255), | ||
9 | passwordSalt varchar(255), | ||
10 | homeRegionX integer, | ||
11 | homeRegionY integer, | ||
12 | homeLocationX float, | ||
13 | homeLocationY float, | ||
14 | homeLocationZ float, | ||
15 | homeLookAtX float, | ||
16 | homeLookAtY float, | ||
17 | homeLookAtZ float, | ||
18 | created integer, | ||
19 | lastLogin integer, | ||
20 | rootInventoryFolderID varchar(255), | ||
21 | userInventoryURI varchar(255), | ||
22 | userAssetURI varchar(255), | ||
23 | profileCanDoMask integer, | ||
24 | profileWantDoMask integer, | ||
25 | profileAboutText varchar(255), | ||
26 | profileFirstText varchar(255), | ||
27 | profileImage varchar(255), | ||
28 | profileFirstImage varchar(255), | ||
29 | webLoginKey text default '00000000-0000-0000-0000-000000000000'); | ||
30 | -- friends table | ||
31 | CREATE TABLE userfriends( | ||
32 | ownerID varchar(255), | ||
33 | friendID varchar(255), | ||
34 | friendPerms integer, | ||
35 | ownerPerms integer, | ||
36 | datetimestamp integer); | ||
37 | |||
38 | COMMIT; | ||
39 | |||
diff --git a/OpenSim/Data/SQLiteNG/Resources/002_AssetStore.sql b/OpenSim/Data/SQLiteNG/Resources/002_AssetStore.sql new file mode 100644 index 0000000..5339b84 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/002_AssetStore.sql | |||
@@ -0,0 +1,10 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | CREATE TEMPORARY TABLE assets_backup(UUID,Name,Description,Type,Local,Temporary,Data); | ||
4 | INSERT INTO assets_backup SELECT UUID,Name,Description,Type,Local,Temporary,Data FROM assets; | ||
5 | DROP TABLE assets; | ||
6 | CREATE TABLE assets(UUID,Name,Description,Type,Local,Temporary,Data); | ||
7 | INSERT INTO assets SELECT UUID,Name,Description,Type,Local,Temporary,Data FROM assets_backup; | ||
8 | DROP TABLE assets_backup; | ||
9 | |||
10 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/002_AuthStore.sql b/OpenSim/Data/SQLiteNG/Resources/002_AuthStore.sql new file mode 100644 index 0000000..3237b68 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/002_AuthStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | INSERT INTO auth (UUID, passwordHash, passwordSalt, webLoginKey) SELECT `UUID` AS UUID, `passwordHash` AS passwordHash, `passwordSalt` AS passwordSalt, `webLoginKey` AS webLoginKey FROM users; | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/002_FriendsStore.sql b/OpenSim/Data/SQLiteNG/Resources/002_FriendsStore.sql new file mode 100644 index 0000000..6733502 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/002_FriendsStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | INSERT INTO `Friends` SELECT `ownerID`, `friendID`, `friendPerms`, 0 FROM `userfriends`; | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/002_InventoryStore.sql b/OpenSim/Data/SQLiteNG/Resources/002_InventoryStore.sql new file mode 100644 index 0000000..01951d6 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/002_InventoryStore.sql | |||
@@ -0,0 +1,8 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | create index inventoryfolders_agentid on inventoryfolders(agentid); | ||
4 | create index inventoryfolders_parentid on inventoryfolders(parentid); | ||
5 | create index inventoryitems_parentfolderid on inventoryitems(parentfolderid); | ||
6 | create index inventoryitems_avatarid on inventoryitems(avatarid); | ||
7 | |||
8 | COMMIT; \ No newline at end of file | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/002_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/002_RegionStore.sql new file mode 100644 index 0000000..c5c7c99 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/002_RegionStore.sql | |||
@@ -0,0 +1,10 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | CREATE TABLE regionban( | ||
4 | regionUUID varchar (255), | ||
5 | bannedUUID varchar (255), | ||
6 | bannedIp varchar (255), | ||
7 | bannedIpHostMask varchar (255) | ||
8 | ); | ||
9 | |||
10 | COMMIT; \ No newline at end of file | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/002_UserAccount.sql b/OpenSim/Data/SQLiteNG/Resources/002_UserAccount.sql new file mode 100644 index 0000000..c7a6293 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/002_UserAccount.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | INSERT INTO UserAccounts (PrincipalID, ScopeID, FirstName, LastName, Email, ServiceURLs, Created) SELECT `UUID` AS PrincipalID, '00000000-0000-0000-0000-000000000000' AS ScopeID, username AS FirstName, surname AS LastName, '' as Email, '' AS ServiceURLs, created as Created FROM users; | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/002_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/002_UserStore.sql new file mode 100644 index 0000000..48fc680 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/002_UserStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE users add homeRegionID varchar(36) NOT NULL default '00000000-0000-0000-0000-000000000000'; | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/003_AssetStore.sql b/OpenSim/Data/SQLiteNG/Resources/003_AssetStore.sql new file mode 100644 index 0000000..f54f8d9 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/003_AssetStore.sql | |||
@@ -0,0 +1 @@ | |||
DELETE FROM assets WHERE UUID = 'dc4b9f0bd00845c696a401dd947ac621' | |||
diff --git a/OpenSim/Data/SQLiteNG/Resources/003_InventoryStore.sql b/OpenSim/Data/SQLiteNG/Resources/003_InventoryStore.sql new file mode 100644 index 0000000..4c6da91 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/003_InventoryStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | alter table inventoryitems add column inventoryGroupPermissions integer unsigned not null default 0; | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/003_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/003_RegionStore.sql new file mode 100644 index 0000000..4db2f75 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/003_RegionStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE primitems add flags integer not null default 0; | ||
4 | |||
5 | COMMIT; \ No newline at end of file | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/003_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/003_UserStore.sql new file mode 100644 index 0000000..6f890ee --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/003_UserStore.sql | |||
@@ -0,0 +1,6 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE users add userFlags integer NOT NULL default 0; | ||
4 | ALTER TABLE users add godLevel integer NOT NULL default 0; | ||
5 | |||
6 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/004_AssetStore.sql b/OpenSim/Data/SQLiteNG/Resources/004_AssetStore.sql new file mode 100644 index 0000000..39421c4 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/004_AssetStore.sql | |||
@@ -0,0 +1,7 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | update assets | ||
4 | set UUID = substr(UUID, 1, 8) || "-" || substr(UUID, 9, 4) || "-" || substr(UUID, 13, 4) || "-" || substr(UUID, 17, 4) || "-" || substr(UUID, 21, 12) | ||
5 | where UUID not like '%-%'; | ||
6 | |||
7 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/004_InventoryStore.sql b/OpenSim/Data/SQLiteNG/Resources/004_InventoryStore.sql new file mode 100644 index 0000000..e8f4d46 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/004_InventoryStore.sql | |||
@@ -0,0 +1,36 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | update inventoryitems | ||
4 | set UUID = substr(UUID, 1, 8) || "-" || substr(UUID, 9, 4) || "-" || substr(UUID, 13, 4) || "-" || substr(UUID, 17, 4) || "-" || substr(UUID, 21, 12) | ||
5 | where UUID not like '%-%'; | ||
6 | |||
7 | update inventoryitems | ||
8 | set assetID = substr(assetID, 1, 8) || "-" || substr(assetID, 9, 4) || "-" || substr(assetID, 13, 4) || "-" || substr(assetID, 17, 4) || "-" || substr(assetID, 21, 12) | ||
9 | where assetID not like '%-%'; | ||
10 | |||
11 | update inventoryitems | ||
12 | set parentFolderID = substr(parentFolderID, 1, 8) || "-" || substr(parentFolderID, 9, 4) || "-" || substr(parentFolderID, 13, 4) || "-" || substr(parentFolderID, 17, 4) || "-" || substr(parentFolderID, 21, 12) | ||
13 | where parentFolderID not like '%-%'; | ||
14 | |||
15 | update inventoryitems | ||
16 | set avatarID = substr(avatarID, 1, 8) || "-" || substr(avatarID, 9, 4) || "-" || substr(avatarID, 13, 4) || "-" || substr(avatarID, 17, 4) || "-" || substr(avatarID, 21, 12) | ||
17 | where avatarID not like '%-%'; | ||
18 | |||
19 | update inventoryitems | ||
20 | set creatorsID = substr(creatorsID, 1, 8) || "-" || substr(creatorsID, 9, 4) || "-" || substr(creatorsID, 13, 4) || "-" || substr(creatorsID, 17, 4) || "-" || substr(creatorsID, 21, 12) | ||
21 | where creatorsID not like '%-%'; | ||
22 | |||
23 | |||
24 | update inventoryfolders | ||
25 | set UUID = substr(UUID, 1, 8) || "-" || substr(UUID, 9, 4) || "-" || substr(UUID, 13, 4) || "-" || substr(UUID, 17, 4) || "-" || substr(UUID, 21, 12) | ||
26 | where UUID not like '%-%'; | ||
27 | |||
28 | update inventoryfolders | ||
29 | set agentID = substr(agentID, 1, 8) || "-" || substr(agentID, 9, 4) || "-" || substr(agentID, 13, 4) || "-" || substr(agentID, 17, 4) || "-" || substr(agentID, 21, 12) | ||
30 | where agentID not like '%-%'; | ||
31 | |||
32 | update inventoryfolders | ||
33 | set parentID = substr(parentID, 1, 8) || "-" || substr(parentID, 9, 4) || "-" || substr(parentID, 13, 4) || "-" || substr(parentID, 17, 4) || "-" || substr(parentID, 21, 12) | ||
34 | where parentID not like '%-%'; | ||
35 | |||
36 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/004_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/004_RegionStore.sql new file mode 100644 index 0000000..de328cb --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/004_RegionStore.sql | |||
@@ -0,0 +1,38 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | create table regionsettings ( | ||
4 | regionUUID char(36) not null, | ||
5 | block_terraform integer not null, | ||
6 | block_fly integer not null, | ||
7 | allow_damage integer not null, | ||
8 | restrict_pushing integer not null, | ||
9 | allow_land_resell integer not null, | ||
10 | allow_land_join_divide integer not null, | ||
11 | block_show_in_search integer not null, | ||
12 | agent_limit integer not null, | ||
13 | object_bonus float not null, | ||
14 | maturity integer not null, | ||
15 | disable_scripts integer not null, | ||
16 | disable_collisions integer not null, | ||
17 | disable_physics integer not null, | ||
18 | terrain_texture_1 char(36) not null, | ||
19 | terrain_texture_2 char(36) not null, | ||
20 | terrain_texture_3 char(36) not null, | ||
21 | terrain_texture_4 char(36) not null, | ||
22 | elevation_1_nw float not null, | ||
23 | elevation_2_nw float not null, | ||
24 | elevation_1_ne float not null, | ||
25 | elevation_2_ne float not null, | ||
26 | elevation_1_se float not null, | ||
27 | elevation_2_se float not null, | ||
28 | elevation_1_sw float not null, | ||
29 | elevation_2_sw float not null, | ||
30 | water_height float not null, | ||
31 | terrain_raise_limit float not null, | ||
32 | terrain_lower_limit float not null, | ||
33 | use_estate_sun integer not null, | ||
34 | fixed_sun integer not null, | ||
35 | sun_position float not null, | ||
36 | covenant char(36)); | ||
37 | |||
38 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/004_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/004_UserStore.sql new file mode 100644 index 0000000..03142af --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/004_UserStore.sql | |||
@@ -0,0 +1,6 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE users add customType varchar(32) not null default ''; | ||
4 | ALTER TABLE users add partner char(36) not null default '00000000-0000-0000-0000-000000000000'; | ||
5 | |||
6 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/005_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/005_RegionStore.sql new file mode 100644 index 0000000..1f6d1bd --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/005_RegionStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | delete from regionsettings; | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/005_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/005_UserStore.sql new file mode 100644 index 0000000..e45c09a --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/005_UserStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | CREATE TABLE `avatarattachments` (`UUID` char(36) NOT NULL DEFAULT '00000000-0000-0000-0000-000000000000', `attachpoint` int(11) NOT NULL DEFAULT 0, `item` char(36) NOT NULL DEFAULT '00000000-0000-0000-0000-000000000000', `asset` char(36) NOT NULL DEFAULT '00000000-0000-0000-0000-000000000000'); | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/006_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/006_RegionStore.sql new file mode 100644 index 0000000..94ed818 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/006_RegionStore.sql | |||
@@ -0,0 +1,102 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | CREATE TABLE estate_groups ( | ||
4 | EstateID int(10) NOT NULL, | ||
5 | uuid char(36) NOT NULL | ||
6 | ); | ||
7 | |||
8 | CREATE TABLE estate_managers ( | ||
9 | EstateID int(10) NOT NULL, | ||
10 | uuid char(36) NOT NULL | ||
11 | ); | ||
12 | |||
13 | CREATE TABLE estate_map ( | ||
14 | RegionID char(36) NOT NULL default '00000000-0000-0000-0000-000000000000', | ||
15 | EstateID int(11) NOT NULL | ||
16 | ); | ||
17 | |||
18 | CREATE TABLE estate_settings ( | ||
19 | EstateID INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT, | ||
20 | EstateName varchar(64) default NULL, | ||
21 | AbuseEmailToEstateOwner tinyint(4) NOT NULL, | ||
22 | DenyAnonymous tinyint(4) NOT NULL, | ||
23 | ResetHomeOnTeleport tinyint(4) NOT NULL, | ||
24 | FixedSun tinyint(4) NOT NULL, | ||
25 | DenyTransacted tinyint(4) NOT NULL, | ||
26 | BlockDwell tinyint(4) NOT NULL, | ||
27 | DenyIdentified tinyint(4) NOT NULL, | ||
28 | AllowVoice tinyint(4) NOT NULL, | ||
29 | UseGlobalTime tinyint(4) NOT NULL, | ||
30 | PricePerMeter int(11) NOT NULL, | ||
31 | TaxFree tinyint(4) NOT NULL, | ||
32 | AllowDirectTeleport tinyint(4) NOT NULL, | ||
33 | RedirectGridX int(11) NOT NULL, | ||
34 | RedirectGridY int(11) NOT NULL, | ||
35 | ParentEstateID int(10) NOT NULL, | ||
36 | SunPosition double NOT NULL, | ||
37 | EstateSkipScripts tinyint(4) NOT NULL, | ||
38 | BillableFactor float NOT NULL, | ||
39 | PublicAccess tinyint(4) NOT NULL | ||
40 | ); | ||
41 | insert into estate_settings (EstateID,EstateName,AbuseEmailToEstateOwner,DenyAnonymous,ResetHomeOnTeleport,FixedSun,DenyTransacted,BlockDwell,DenyIdentified,AllowVoice,UseGlobalTime,PricePerMeter,TaxFree,AllowDirectTeleport,RedirectGridX,RedirectGridY,ParentEstateID,SunPosition,PublicAccess,EstateSkipScripts,BillableFactor) values ( 99, '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', '', ''); | ||
42 | delete from estate_settings; | ||
43 | CREATE TABLE estate_users ( | ||
44 | EstateID int(10) NOT NULL, | ||
45 | uuid char(36) NOT NULL | ||
46 | ); | ||
47 | |||
48 | CREATE TABLE estateban ( | ||
49 | EstateID int(10) NOT NULL, | ||
50 | bannedUUID varchar(36) NOT NULL, | ||
51 | bannedIp varchar(16) NOT NULL, | ||
52 | bannedIpHostMask varchar(16) NOT NULL, | ||
53 | bannedNameMask varchar(64) default NULL | ||
54 | ); | ||
55 | |||
56 | drop table regionsettings; | ||
57 | CREATE TABLE regionsettings ( | ||
58 | regionUUID char(36) NOT NULL, | ||
59 | block_terraform int(11) NOT NULL, | ||
60 | block_fly int(11) NOT NULL, | ||
61 | allow_damage int(11) NOT NULL, | ||
62 | restrict_pushing int(11) NOT NULL, | ||
63 | allow_land_resell int(11) NOT NULL, | ||
64 | allow_land_join_divide int(11) NOT NULL, | ||
65 | block_show_in_search int(11) NOT NULL, | ||
66 | agent_limit int(11) NOT NULL, | ||
67 | object_bonus float NOT NULL, | ||
68 | maturity int(11) NOT NULL, | ||
69 | disable_scripts int(11) NOT NULL, | ||
70 | disable_collisions int(11) NOT NULL, | ||
71 | disable_physics int(11) NOT NULL, | ||
72 | terrain_texture_1 char(36) NOT NULL, | ||
73 | terrain_texture_2 char(36) NOT NULL, | ||
74 | terrain_texture_3 char(36) NOT NULL, | ||
75 | terrain_texture_4 char(36) NOT NULL, | ||
76 | elevation_1_nw float NOT NULL, | ||
77 | elevation_2_nw float NOT NULL, | ||
78 | elevation_1_ne float NOT NULL, | ||
79 | elevation_2_ne float NOT NULL, | ||
80 | elevation_1_se float NOT NULL, | ||
81 | elevation_2_se float NOT NULL, | ||
82 | elevation_1_sw float NOT NULL, | ||
83 | elevation_2_sw float NOT NULL, | ||
84 | water_height float NOT NULL, | ||
85 | terrain_raise_limit float NOT NULL, | ||
86 | terrain_lower_limit float NOT NULL, | ||
87 | use_estate_sun int(11) NOT NULL, | ||
88 | fixed_sun int(11) NOT NULL, | ||
89 | sun_position float NOT NULL, | ||
90 | covenant char(36) default NULL, | ||
91 | Sandbox tinyint(4) NOT NULL, | ||
92 | PRIMARY KEY (regionUUID) | ||
93 | ); | ||
94 | |||
95 | CREATE INDEX estate_ban_estate_id on estateban(EstateID); | ||
96 | CREATE INDEX estate_groups_estate_id on estate_groups(EstateID); | ||
97 | CREATE INDEX estate_managers_estate_id on estate_managers(EstateID); | ||
98 | CREATE INDEX estate_map_estate_id on estate_map(EstateID); | ||
99 | CREATE UNIQUE INDEX estate_map_region_id on estate_map(RegionID); | ||
100 | CREATE INDEX estate_users_estate_id on estate_users(EstateID); | ||
101 | |||
102 | COMMIT; \ No newline at end of file | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/006_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/006_UserStore.sql new file mode 100644 index 0000000..f9454c5 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/006_UserStore.sql | |||
@@ -0,0 +1,20 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | -- usersagents table | ||
4 | CREATE TABLE IF NOT EXISTS useragents( | ||
5 | UUID varchar(255) primary key, | ||
6 | agentIP varchar(255), | ||
7 | agentPort integer, | ||
8 | agentOnline boolean, | ||
9 | sessionID varchar(255), | ||
10 | secureSessionID varchar(255), | ||
11 | regionID varchar(255), | ||
12 | loginTime integer, | ||
13 | logoutTime integer, | ||
14 | currentRegion varchar(255), | ||
15 | currentHandle varchar(255), | ||
16 | currentPosX float, | ||
17 | currentPosY float, | ||
18 | currentPosZ float); | ||
19 | |||
20 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/007_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/007_RegionStore.sql new file mode 100644 index 0000000..1c813a0 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/007_RegionStore.sql | |||
@@ -0,0 +1,8 @@ | |||
1 | begin; | ||
2 | |||
3 | alter table estate_settings add column AbuseEmail varchar(255) not null default ''; | ||
4 | |||
5 | alter table estate_settings add column EstateOwner varchar(36) not null default ''; | ||
6 | |||
7 | commit; | ||
8 | |||
diff --git a/OpenSim/Data/SQLiteNG/Resources/007_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/007_UserStore.sql new file mode 100644 index 0000000..8b0cd28 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/007_UserStore.sql | |||
@@ -0,0 +1,7 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | ALTER TABLE useragents add currentLookAtX float not null default 128; | ||
4 | ALTER TABLE useragents add currentLookAtY float not null default 128; | ||
5 | ALTER TABLE useragents add currentLookAtZ float not null default 70; | ||
6 | |||
7 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/008_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/008_RegionStore.sql new file mode 100644 index 0000000..28bfbf5 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/008_RegionStore.sql | |||
@@ -0,0 +1,6 @@ | |||
1 | begin; | ||
2 | |||
3 | alter table estate_settings add column DenyMinors tinyint not null default 0; | ||
4 | |||
5 | commit; | ||
6 | |||
diff --git a/OpenSim/Data/SQLiteNG/Resources/008_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/008_UserStore.sql new file mode 100644 index 0000000..97da818 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/008_UserStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | ALTER TABLE users add email varchar(250); | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/009_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/009_RegionStore.sql new file mode 100644 index 0000000..1f40548 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/009_RegionStore.sql | |||
@@ -0,0 +1,8 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE prims ADD COLUMN ColorR integer not null default 0; | ||
4 | ALTER TABLE prims ADD COLUMN ColorG integer not null default 0; | ||
5 | ALTER TABLE prims ADD COLUMN ColorB integer not null default 0; | ||
6 | ALTER TABLE prims ADD COLUMN ColorA integer not null default 0; | ||
7 | |||
8 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/009_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/009_UserStore.sql new file mode 100644 index 0000000..8ab03ef --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/009_UserStore.sql | |||
@@ -0,0 +1,11 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | update users | ||
4 | set UUID = substr(UUID, 1, 8) || "-" || substr(UUID, 9, 4) || "-" || substr(UUID, 13, 4) || "-" || substr(UUID, 17, 4) || "-" || substr(UUID, 21, 12) | ||
5 | where UUID not like '%-%'; | ||
6 | |||
7 | update useragents | ||
8 | set UUID = substr(UUID, 1, 8) || "-" || substr(UUID, 9, 4) || "-" || substr(UUID, 13, 4) || "-" || substr(UUID, 17, 4) || "-" || substr(UUID, 21, 12) | ||
9 | where UUID not like '%-%'; | ||
10 | |||
11 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/010_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/010_RegionStore.sql new file mode 100644 index 0000000..b91ccf0 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/010_RegionStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE prims ADD COLUMN ClickAction INTEGER NOT NULL default 0; | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/010_UserStore.sql b/OpenSim/Data/SQLiteNG/Resources/010_UserStore.sql new file mode 100644 index 0000000..5f956da --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/010_UserStore.sql | |||
@@ -0,0 +1,37 @@ | |||
1 | BEGIN TRANSACTION; | ||
2 | |||
3 | CREATE TABLE IF NOT EXISTS avatarappearance( | ||
4 | Owner varchar(36) NOT NULL primary key, | ||
5 | BodyItem varchar(36) DEFAULT NULL, | ||
6 | BodyAsset varchar(36) DEFAULT NULL, | ||
7 | SkinItem varchar(36) DEFAULT NULL, | ||
8 | SkinAsset varchar(36) DEFAULT NULL, | ||
9 | HairItem varchar(36) DEFAULT NULL, | ||
10 | HairAsset varchar(36) DEFAULT NULL, | ||
11 | EyesItem varchar(36) DEFAULT NULL, | ||
12 | EyesAsset varchar(36) DEFAULT NULL, | ||
13 | ShirtItem varchar(36) DEFAULT NULL, | ||
14 | ShirtAsset varchar(36) DEFAULT NULL, | ||
15 | PantsItem varchar(36) DEFAULT NULL, | ||
16 | PantsAsset varchar(36) DEFAULT NULL, | ||
17 | ShoesItem varchar(36) DEFAULT NULL, | ||
18 | ShoesAsset varchar(36) DEFAULT NULL, | ||
19 | SocksItem varchar(36) DEFAULT NULL, | ||
20 | SocksAsset varchar(36) DEFAULT NULL, | ||
21 | JacketItem varchar(36) DEFAULT NULL, | ||
22 | JacketAsset varchar(36) DEFAULT NULL, | ||
23 | GlovesItem varchar(36) DEFAULT NULL, | ||
24 | GlovesAsset varchar(36) DEFAULT NULL, | ||
25 | UnderShirtItem varchar(36) DEFAULT NULL, | ||
26 | UnderShirtAsset varchar(36) DEFAULT NULL, | ||
27 | UnderPantsItem varchar(36) DEFAULT NULL, | ||
28 | UnderPantsAsset varchar(36) DEFAULT NULL, | ||
29 | SkirtItem varchar(36) DEFAULT NULL, | ||
30 | SkirtAsset varchar(36) DEFAULT NULL, | ||
31 | Texture blob, | ||
32 | VisualParams blob, | ||
33 | Serial int DEFAULT NULL, | ||
34 | AvatarHeight float DEFAULT NULL | ||
35 | ); | ||
36 | |||
37 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/011_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/011_RegionStore.sql new file mode 100644 index 0000000..42bef89 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/011_RegionStore.sql | |||
@@ -0,0 +1,28 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE prims ADD COLUMN PayPrice INTEGER NOT NULL default 0; | ||
4 | ALTER TABLE prims ADD COLUMN PayButton1 INTEGER NOT NULL default 0; | ||
5 | ALTER TABLE prims ADD COLUMN PayButton2 INTEGER NOT NULL default 0; | ||
6 | ALTER TABLE prims ADD COLUMN PayButton3 INTEGER NOT NULL default 0; | ||
7 | ALTER TABLE prims ADD COLUMN PayButton4 INTEGER NOT NULL default 0; | ||
8 | ALTER TABLE prims ADD COLUMN LoopedSound varchar(36) NOT NULL default '00000000-0000-0000-0000-000000000000'; | ||
9 | ALTER TABLE prims ADD COLUMN LoopedSoundGain float NOT NULL default 0; | ||
10 | ALTER TABLE prims ADD COLUMN TextureAnimation string; | ||
11 | ALTER TABLE prims ADD COLUMN ParticleSystem string; | ||
12 | ALTER TABLE prims ADD COLUMN OmegaX float NOT NULL default 0; | ||
13 | ALTER TABLE prims ADD COLUMN OmegaY float NOT NULL default 0; | ||
14 | ALTER TABLE prims ADD COLUMN OmegaZ float NOT NULL default 0; | ||
15 | ALTER TABLE prims ADD COLUMN CameraEyeOffsetX float NOT NULL default 0; | ||
16 | ALTER TABLE prims ADD COLUMN CameraEyeOffsetY float NOT NULL default 0; | ||
17 | ALTER TABLE prims ADD COLUMN CameraEyeOffsetZ float NOT NULL default 0; | ||
18 | ALTER TABLE prims ADD COLUMN CameraAtOffsetX float NOT NULL default 0; | ||
19 | ALTER TABLE prims ADD COLUMN CameraAtOffsetY float NOT NULL default 0; | ||
20 | ALTER TABLE prims ADD COLUMN CameraAtOffsetZ float NOT NULL default 0; | ||
21 | ALTER TABLE prims ADD COLUMN ForceMouselook string NOT NULL default 0; | ||
22 | ALTER TABLE prims ADD COLUMN ScriptAccessPin INTEGER NOT NULL default 0; | ||
23 | ALTER TABLE prims ADD COLUMN AllowedDrop INTEGER NOT NULL default 0; | ||
24 | ALTER TABLE prims ADD COLUMN DieAtEdge string NOT NULL default 0; | ||
25 | ALTER TABLE prims ADD COLUMN SalePrice INTEGER NOT NULL default 0; | ||
26 | ALTER TABLE prims ADD COLUMN SaleType string NOT NULL default 0; | ||
27 | |||
28 | COMMIT; \ No newline at end of file | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/012_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/012_RegionStore.sql new file mode 100644 index 0000000..d952b78 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/012_RegionStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE prims ADD COLUMN Material INTEGER NOT NULL default 3; | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/013_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/013_RegionStore.sql new file mode 100644 index 0000000..11529cd --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/013_RegionStore.sql | |||
@@ -0,0 +1,6 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE land ADD COLUMN OtherCleanTime INTEGER NOT NULL default 0; | ||
4 | ALTER TABLE land ADD COLUMN Dwell INTEGER NOT NULL default 0; | ||
5 | |||
6 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/014_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/014_RegionStore.sql new file mode 100644 index 0000000..c59b27e --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/014_RegionStore.sql | |||
@@ -0,0 +1,8 @@ | |||
1 | begin; | ||
2 | |||
3 | ALTER TABLE regionsettings ADD COLUMN sunvectorx double NOT NULL default 0; | ||
4 | ALTER TABLE regionsettings ADD COLUMN sunvectory double NOT NULL default 0; | ||
5 | ALTER TABLE regionsettings ADD COLUMN sunvectorz double NOT NULL default 0; | ||
6 | |||
7 | commit; | ||
8 | |||
diff --git a/OpenSim/Data/SQLiteNG/Resources/015_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/015_RegionStore.sql new file mode 100644 index 0000000..c43f356 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/015_RegionStore.sql | |||
@@ -0,0 +1,6 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE prims ADD COLUMN CollisionSound varchar(36) NOT NULL default '00000000-0000-0000-0000-000000000000'; | ||
4 | ALTER TABLE prims ADD COLUMN CollisionSoundVolume float NOT NULL default 0; | ||
5 | |||
6 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/016_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/016_RegionStore.sql new file mode 100644 index 0000000..52f160c --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/016_RegionStore.sql | |||
@@ -0,0 +1,5 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | ALTER TABLE prims ADD COLUMN VolumeDetect INTEGER NOT NULL DEFAULT 0; | ||
4 | |||
5 | COMMIT; | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/017_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/017_RegionStore.sql new file mode 100644 index 0000000..6c6b7b5 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/017_RegionStore.sql | |||
@@ -0,0 +1,8 @@ | |||
1 | BEGIN; | ||
2 | CREATE TEMPORARY TABLE prims_backup(UUID,RegionUUID,CreationDate,Name,SceneGroupID,Text,Description,SitName,TouchName,CreatorID,OwnerID,GroupID,LastOwnerID,OwnerMask,NextOwnerMask,GroupMask,EveryoneMask,BaseMask,PositionX,PositionY,PositionZ,GroupPositionX,GroupPositionY,GroupPositionZ,VelocityX,VelocityY,VelocityZ,AngularVelocityX,AngularVelocityY,AngularVelocityZ,AccelerationX,AccelerationY,AccelerationZ,RotationX,RotationY,RotationZ,RotationW,ObjectFlags,SitTargetOffsetX,SitTargetOffsetY,SitTargetOffsetZ,SitTargetOrientW,SitTargetOrientX,SitTargetOrientY,SitTargetOrientZ,ColorR,ColorG,ColorB,ColorA,ClickAction,PayPrice,PayButton1,PayButton2,PayButton3,PayButton4,LoopedSound,LoopedSoundGain,TextureAnimation,ParticleSystem,OmegaX,OmegaY,OmegaZ,CameraEyeOffsetX,CameraEyeOffsetY,CameraEyeOffsetZ,CameraAtOffsetX,CameraAtOffsetY,CameraAtOffsetZ,ForceMouselook,ScriptAccessPin,AllowedDrop,DieAtEdge,SalePrice,SaleType,Material,CollisionSound,CollisionSoundVolume,VolumeDetect); | ||
3 | INSERT INTO prims_backup SELECT UUID,RegionUUID,CreationDate,Name,SceneGroupID,Text,Description,SitName,TouchName,CreatorID,OwnerID,GroupID,LastOwnerID,OwnerMask,NextOwnerMask,GroupMask,EveryoneMask,BaseMask,PositionX,PositionY,PositionZ,GroupPositionX,GroupPositionY,GroupPositionZ,VelocityX,VelocityY,VelocityZ,AngularVelocityX,AngularVelocityY,AngularVelocityZ,AccelerationX,AccelerationY,AccelerationZ,RotationX,RotationY,RotationZ,RotationW,ObjectFlags,SitTargetOffsetX,SitTargetOffsetY,SitTargetOffsetZ,SitTargetOrientW,SitTargetOrientX,SitTargetOrientY,SitTargetOrientZ,ColorR,ColorG,ColorB,ColorA,ClickAction,PayPrice,PayButton1,PayButton2,PayButton3,PayButton4,LoopedSound,LoopedSoundGain,TextureAnimation,ParticleSystem,OmegaX,OmegaY,OmegaZ,CameraEyeOffsetX,CameraEyeOffsetY,CameraEyeOffsetZ,CameraAtOffsetX,CameraAtOffsetY,CameraAtOffsetZ,ForceMouselook,ScriptAccessPin,AllowedDrop,DieAtEdge,SalePrice,SaleType,Material,CollisionSound,CollisionSoundVolume,VolumeDetect FROM prims; | ||
4 | DROP TABLE prims; | ||
5 | CREATE TABLE prims(UUID,RegionUUID,CreationDate,Name,SceneGroupID,Text,Description,SitName,TouchName,CreatorID,OwnerID,GroupID,LastOwnerID,OwnerMask,NextOwnerMask,GroupMask,EveryoneMask,BaseMask,PositionX,PositionY,PositionZ,GroupPositionX,GroupPositionY,GroupPositionZ,VelocityX,VelocityY,VelocityZ,AngularVelocityX,AngularVelocityY,AngularVelocityZ,AccelerationX,AccelerationY,AccelerationZ,RotationX,RotationY,RotationZ,RotationW,ObjectFlags,SitTargetOffsetX,SitTargetOffsetY,SitTargetOffsetZ,SitTargetOrientW,SitTargetOrientX,SitTargetOrientY,SitTargetOrientZ,ColorR,ColorG,ColorB,ColorA,ClickAction,PayPrice,PayButton1,PayButton2,PayButton3,PayButton4,LoopedSound,LoopedSoundGain,TextureAnimation,ParticleSystem,OmegaX,OmegaY,OmegaZ,CameraEyeOffsetX,CameraEyeOffsetY,CameraEyeOffsetZ,CameraAtOffsetX,CameraAtOffsetY,CameraAtOffsetZ,ForceMouselook,ScriptAccessPin,AllowedDrop,DieAtEdge,SalePrice,SaleType,Material,CollisionSound,CollisionSoundVolume,VolumeDetect); | ||
6 | INSERT INTO prims SELECT UUID,RegionUUID,CreationDate,Name,SceneGroupID,Text,Description,SitName,TouchName,CreatorID,OwnerID,GroupID,LastOwnerID,OwnerMask,NextOwnerMask,GroupMask,EveryoneMask,BaseMask,PositionX,PositionY,PositionZ,GroupPositionX,GroupPositionY,GroupPositionZ,VelocityX,VelocityY,VelocityZ,AngularVelocityX,AngularVelocityY,AngularVelocityZ,AccelerationX,AccelerationY,AccelerationZ,RotationX,RotationY,RotationZ,RotationW,ObjectFlags,SitTargetOffsetX,SitTargetOffsetY,SitTargetOffsetZ,SitTargetOrientW,SitTargetOrientX,SitTargetOrientY,SitTargetOrientZ,ColorR,ColorG,ColorB,ColorA,ClickAction,PayPrice,PayButton1,PayButton2,PayButton3,PayButton4,LoopedSound,LoopedSoundGain,TextureAnimation,ParticleSystem,OmegaX,OmegaY,OmegaZ,CameraEyeOffsetX,CameraEyeOffsetY,CameraEyeOffsetZ,CameraAtOffsetX,CameraAtOffsetY,CameraAtOffsetZ,ForceMouselook,ScriptAccessPin,AllowedDrop,DieAtEdge,SalePrice,SaleType,Material,CollisionSound,CollisionSoundVolume,VolumeDetect FROM prims_backup; | ||
7 | DROP TABLE prims_backup; | ||
8 | COMMIT; \ No newline at end of file | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/018_RegionStore.sql b/OpenSim/Data/SQLiteNG/Resources/018_RegionStore.sql new file mode 100644 index 0000000..6a390c2 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/018_RegionStore.sql | |||
@@ -0,0 +1,79 @@ | |||
1 | BEGIN; | ||
2 | |||
3 | update terrain | ||
4 | set RegionUUID = substr(RegionUUID, 1, 8) || "-" || substr(RegionUUID, 9, 4) || "-" || substr(RegionUUID, 13, 4) || "-" || substr(RegionUUID, 17, 4) || "-" || substr(RegionUUID, 21, 12) | ||
5 | where RegionUUID not like '%-%'; | ||
6 | |||
7 | |||
8 | update landaccesslist | ||
9 | set LandUUID = substr(LandUUID, 1, 8) || "-" || substr(LandUUID, 9, 4) || "-" || substr(LandUUID, 13, 4) || "-" || substr(LandUUID, 17, 4) || "-" || substr(LandUUID, 21, 12) | ||
10 | where LandUUID not like '%-%'; | ||
11 | |||
12 | update landaccesslist | ||
13 | set AccessUUID = substr(AccessUUID, 1, 8) || "-" || substr(AccessUUID, 9, 4) || "-" || substr(AccessUUID, 13, 4) || "-" || substr(AccessUUID, 17, 4) || "-" || substr(AccessUUID, 21, 12) | ||
14 | where AccessUUID not like '%-%'; | ||
15 | |||
16 | |||
17 | update prims | ||
18 | set UUID = substr(UUID, 1, 8) || "-" || substr(UUID, 9, 4) || "-" || substr(UUID, 13, 4) || "-" || substr(UUID, 17, 4) || "-" || substr(UUID, 21, 12) | ||
19 | where UUID not like '%-%'; | ||
20 | |||
21 | update prims | ||
22 | set RegionUUID = substr(RegionUUID, 1, 8) || "-" || substr(RegionUUID, 9, 4) || "-" || substr(RegionUUID, 13, 4) || "-" || substr(RegionUUID, 17, 4) || "-" || substr(RegionUUID, 21, 12) | ||
23 | where RegionUUID not like '%-%'; | ||
24 | |||
25 | update prims | ||
26 | set SceneGroupID = substr(SceneGroupID, 1, 8) || "-" || substr(SceneGroupID, 9, 4) || "-" || substr(SceneGroupID, 13, 4) || "-" || substr(SceneGroupID, 17, 4) || "-" || substr(SceneGroupID, 21, 12) | ||
27 | where SceneGroupID not like '%-%'; | ||
28 | |||
29 | update prims | ||
30 | set CreatorID = substr(CreatorID, 1, 8) || "-" || substr(CreatorID, 9, 4) || "-" || substr(CreatorID, 13, 4) || "-" || substr(CreatorID, 17, 4) || "-" || substr(CreatorID, 21, 12) | ||
31 | where CreatorID not like '%-%'; | ||
32 | |||
33 | update prims | ||
34 | set OwnerID = substr(OwnerID, 1, 8) || "-" || substr(OwnerID, 9, 4) || "-" || substr(OwnerID, 13, 4) || "-" || substr(OwnerID, 17, 4) || "-" || substr(OwnerID, 21, 12) | ||
35 | where OwnerID not like '%-%'; | ||
36 | |||
37 | update prims | ||
38 | set GroupID = substr(GroupID, 1, 8) || "-" || substr(GroupID, 9, 4) || "-" || substr(GroupID, 13, 4) || "-" || substr(GroupID, 17, 4) || "-" || substr(GroupID, 21, 12) | ||
39 | where GroupID not like '%-%'; | ||
40 | |||
41 | update prims | ||
42 | set LastOwnerID = substr(LastOwnerID, 1, 8) || "-" || substr(LastOwnerID, 9, 4) || "-" || substr(LastOwnerID, 13, 4) || "-" || substr(LastOwnerID, 17, 4) || "-" || substr(LastOwnerID, 21, 12) | ||
43 | where LastOwnerID not like '%-%'; | ||
44 | |||
45 | |||
46 | update primshapes | ||
47 | set UUID = substr(UUID, 1, 8) || "-" || substr(UUID, 9, 4) || "-" || substr(UUID, 13, 4) || "-" || substr(UUID, 17, 4) || "-" || substr(UUID, 21, 12) | ||
48 | where UUID not like '%-%'; | ||
49 | |||
50 | |||
51 | update land | ||
52 | set UUID = substr(UUID, 1, 8) || "-" || substr(UUID, 9, 4) || "-" || substr(UUID, 13, 4) || "-" || substr(UUID, 17, 4) || "-" || substr(UUID, 21, 12) | ||
53 | where UUID not like '%-%'; | ||
54 | |||
55 | update land | ||
56 | set RegionUUID = substr(RegionUUID, 1, 8) || "-" || substr(RegionUUID, 9, 4) || "-" || substr(RegionUUID, 13, 4) || "-" || substr(RegionUUID, 17, 4) || "-" || substr(RegionUUID, 21, 12) | ||
57 | where RegionUUID not like '%-%'; | ||
58 | |||
59 | update land | ||
60 | set OwnerUUID = substr(OwnerUUID, 1, 8) || "-" || substr(OwnerUUID, 9, 4) || "-" || substr(OwnerUUID, 13, 4) || "-" || substr(OwnerUUID, 17, 4) || "-" || substr(OwnerUUID, 21, 12) | ||
61 | where OwnerUUID not like '%-%'; | ||
62 | |||
63 | update land | ||
64 | set GroupUUID = substr(GroupUUID, 1, 8) || "-" || substr(GroupUUID, 9, 4) || "-" || substr(GroupUUID, 13, 4) || "-" || substr(GroupUUID, 17, 4) || "-" || substr(GroupUUID, 21, 12) | ||
65 | where GroupUUID not like '%-%'; | ||
66 | |||
67 | update land | ||
68 | set MediaTextureUUID = substr(MediaTextureUUID, 1, 8) || "-" || substr(MediaTextureUUID, 9, 4) || "-" || substr(MediaTextureUUID, 13, 4) || "-" || substr(MediaTextureUUID, 17, 4) || "-" || substr(MediaTextureUUID, 21, 12) | ||
69 | where MediaTextureUUID not like '%-%'; | ||
70 | |||
71 | update land | ||
72 | set SnapshotUUID = substr(SnapshotUUID, 1, 8) || "-" || substr(SnapshotUUID, 9, 4) || "-" || substr(SnapshotUUID, 13, 4) || "-" || substr(SnapshotUUID, 17, 4) || "-" || substr(SnapshotUUID, 21, 12) | ||
73 | where SnapshotUUID not like '%-%'; | ||
74 | |||
75 | update land | ||
76 | set AuthbuyerID = substr(AuthbuyerID, 1, 8) || "-" || substr(AuthbuyerID, 9, 4) || "-" || substr(AuthbuyerID, 13, 4) || "-" || substr(AuthbuyerID, 17, 4) || "-" || substr(AuthbuyerID, 21, 12) | ||
77 | where AuthbuyerID not like '%-%'; | ||
78 | |||
79 | COMMIT; \ No newline at end of file | ||
diff --git a/OpenSim/Data/SQLiteNG/Resources/OpenSim.Data.SQLite.addin.xml b/OpenSim/Data/SQLiteNG/Resources/OpenSim.Data.SQLite.addin.xml new file mode 100644 index 0000000..e6764fa --- /dev/null +++ b/OpenSim/Data/SQLiteNG/Resources/OpenSim.Data.SQLite.addin.xml | |||
@@ -0,0 +1,20 @@ | |||
1 | <Addin id="OpenSim.Data.SQLite" version="0.1"> | ||
2 | <Runtime> | ||
3 | <Import assembly="OpenSim.Data.SQLite.dll"/> | ||
4 | </Runtime> | ||
5 | <Dependencies> | ||
6 | <Addin id="OpenSim.Data" version="0.5" /> | ||
7 | </Dependencies> | ||
8 | <Extension path = "/OpenSim/GridData"> | ||
9 | <Plugin id="SQLiteGridData" provider="OpenSim.Data.SQLite.dll" type="OpenSim.Data.SQLite.SQLiteGridData" /> | ||
10 | </Extension> | ||
11 | <Extension path = "/OpenSim/AssetData"> | ||
12 | <Plugin id="SQLiteAssetData" provider="OpenSim.Data.SQLite.dll" type="OpenSim.Data.SQLite.SQLiteAssetData" /> | ||
13 | </Extension> | ||
14 | <Extension path = "/OpenSim/InventoryData"> | ||
15 | <Plugin id="SQLiteInventoryData" provider="OpenSim.Data.SQLite.dll" type="OpenSim.Data.SQLite.SQLiteInventoryStore" /> | ||
16 | </Extension> | ||
17 | <Extension path = "/OpenSim/UserData"> | ||
18 | <Plugin id="SQLiteUserData" provider="OpenSim.Data.SQLite.dll" type="OpenSim.Data.SQLite.SQLiteUserData" /> | ||
19 | </Extension> | ||
20 | </Addin> | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteAssetData.cs b/OpenSim/Data/SQLiteNG/SQLiteAssetData.cs new file mode 100644 index 0000000..636bf86 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteAssetData.cs | |||
@@ -0,0 +1,343 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Data; | ||
30 | using System.Reflection; | ||
31 | using System.Collections.Generic; | ||
32 | using log4net; | ||
33 | using Mono.Data.Sqlite; | ||
34 | using OpenMetaverse; | ||
35 | using OpenSim.Framework; | ||
36 | |||
37 | namespace OpenSim.Data.SQLite | ||
38 | { | ||
39 | /// <summary> | ||
40 | /// An asset storage interface for the SQLite database system | ||
41 | /// </summary> | ||
42 | public class SQLiteAssetData : AssetDataBase | ||
43 | { | ||
44 | // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
45 | |||
46 | private const string SelectAssetSQL = "select * from assets where UUID=:UUID"; | ||
47 | private const string SelectAssetMetadataSQL = "select Name, Description, Type, Temporary, UUID from assets limit :start, :count"; | ||
48 | private const string DeleteAssetSQL = "delete from assets where UUID=:UUID"; | ||
49 | private const string InsertAssetSQL = "insert into assets(UUID, Name, Description, Type, Local, Temporary, Data) values(:UUID, :Name, :Description, :Type, :Local, :Temporary, :Data)"; | ||
50 | private const string UpdateAssetSQL = "update assets set Name=:Name, Description=:Description, Type=:Type, Local=:Local, Temporary=:Temporary, Data=:Data where UUID=:UUID"; | ||
51 | private const string assetSelect = "select * from assets"; | ||
52 | |||
53 | private SqliteConnection m_conn; | ||
54 | |||
55 | override public void Dispose() | ||
56 | { | ||
57 | if (m_conn != null) | ||
58 | { | ||
59 | m_conn.Close(); | ||
60 | m_conn = null; | ||
61 | } | ||
62 | } | ||
63 | |||
64 | /// <summary> | ||
65 | /// <list type="bullet"> | ||
66 | /// <item>Initialises AssetData interface</item> | ||
67 | /// <item>Loads and initialises a new SQLite connection and maintains it.</item> | ||
68 | /// <item>use default URI if connect string is empty.</item> | ||
69 | /// </list> | ||
70 | /// </summary> | ||
71 | /// <param name="dbconnect">connect string</param> | ||
72 | override public void Initialise(string dbconnect) | ||
73 | { | ||
74 | if (dbconnect == string.Empty) | ||
75 | { | ||
76 | dbconnect = "URI=file:Asset.db,version=3"; | ||
77 | } | ||
78 | m_conn = new SqliteConnection(dbconnect); | ||
79 | m_conn.Open(); | ||
80 | |||
81 | Assembly assem = GetType().Assembly; | ||
82 | Migration m = new Migration(m_conn, assem, "AssetStore"); | ||
83 | m.Update(); | ||
84 | |||
85 | return; | ||
86 | } | ||
87 | |||
88 | /// <summary> | ||
89 | /// Fetch Asset | ||
90 | /// </summary> | ||
91 | /// <param name="uuid">UUID of ... ?</param> | ||
92 | /// <returns>Asset base</returns> | ||
93 | override public AssetBase GetAsset(UUID uuid) | ||
94 | { | ||
95 | lock (this) | ||
96 | { | ||
97 | using (SqliteCommand cmd = new SqliteCommand(SelectAssetSQL, m_conn)) | ||
98 | { | ||
99 | cmd.Parameters.Add(new SqliteParameter(":UUID", uuid.ToString())); | ||
100 | using (IDataReader reader = cmd.ExecuteReader()) | ||
101 | { | ||
102 | if (reader.Read()) | ||
103 | { | ||
104 | AssetBase asset = buildAsset(reader); | ||
105 | reader.Close(); | ||
106 | return asset; | ||
107 | } | ||
108 | else | ||
109 | { | ||
110 | reader.Close(); | ||
111 | return null; | ||
112 | } | ||
113 | } | ||
114 | } | ||
115 | } | ||
116 | } | ||
117 | |||
118 | /// <summary> | ||
119 | /// Create an asset | ||
120 | /// </summary> | ||
121 | /// <param name="asset">Asset Base</param> | ||
122 | override public void StoreAsset(AssetBase asset) | ||
123 | { | ||
124 | //m_log.Info("[ASSET DB]: Creating Asset " + asset.FullID.ToString()); | ||
125 | if (ExistsAsset(asset.FullID)) | ||
126 | { | ||
127 | //LogAssetLoad(asset); | ||
128 | |||
129 | lock (this) | ||
130 | { | ||
131 | using (SqliteCommand cmd = new SqliteCommand(UpdateAssetSQL, m_conn)) | ||
132 | { | ||
133 | cmd.Parameters.Add(new SqliteParameter(":UUID", asset.FullID.ToString())); | ||
134 | cmd.Parameters.Add(new SqliteParameter(":Name", asset.Name)); | ||
135 | cmd.Parameters.Add(new SqliteParameter(":Description", asset.Description)); | ||
136 | cmd.Parameters.Add(new SqliteParameter(":Type", asset.Type)); | ||
137 | cmd.Parameters.Add(new SqliteParameter(":Local", asset.Local)); | ||
138 | cmd.Parameters.Add(new SqliteParameter(":Temporary", asset.Temporary)); | ||
139 | cmd.Parameters.Add(new SqliteParameter(":Data", asset.Data)); | ||
140 | |||
141 | cmd.ExecuteNonQuery(); | ||
142 | } | ||
143 | } | ||
144 | } | ||
145 | else | ||
146 | { | ||
147 | lock (this) | ||
148 | { | ||
149 | using (SqliteCommand cmd = new SqliteCommand(InsertAssetSQL, m_conn)) | ||
150 | { | ||
151 | cmd.Parameters.Add(new SqliteParameter(":UUID", asset.FullID.ToString())); | ||
152 | cmd.Parameters.Add(new SqliteParameter(":Name", asset.Name)); | ||
153 | cmd.Parameters.Add(new SqliteParameter(":Description", asset.Description)); | ||
154 | cmd.Parameters.Add(new SqliteParameter(":Type", asset.Type)); | ||
155 | cmd.Parameters.Add(new SqliteParameter(":Local", asset.Local)); | ||
156 | cmd.Parameters.Add(new SqliteParameter(":Temporary", asset.Temporary)); | ||
157 | cmd.Parameters.Add(new SqliteParameter(":Data", asset.Data)); | ||
158 | |||
159 | cmd.ExecuteNonQuery(); | ||
160 | } | ||
161 | } | ||
162 | } | ||
163 | } | ||
164 | |||
165 | // /// <summary> | ||
166 | // /// Some... logging functionnality | ||
167 | // /// </summary> | ||
168 | // /// <param name="asset"></param> | ||
169 | // private static void LogAssetLoad(AssetBase asset) | ||
170 | // { | ||
171 | // string temporary = asset.Temporary ? "Temporary" : "Stored"; | ||
172 | // string local = asset.Local ? "Local" : "Remote"; | ||
173 | // | ||
174 | // int assetLength = (asset.Data != null) ? asset.Data.Length : 0; | ||
175 | // | ||
176 | // m_log.Debug("[ASSET DB]: " + | ||
177 | // string.Format("Loaded {5} {4} Asset: [{0}][{3}] \"{1}\":{2} ({6} bytes)", | ||
178 | // asset.FullID, asset.Name, asset.Description, asset.Type, | ||
179 | // temporary, local, assetLength)); | ||
180 | // } | ||
181 | |||
182 | /// <summary> | ||
183 | /// Check if an asset exist in database | ||
184 | /// </summary> | ||
185 | /// <param name="uuid">The asset UUID</param> | ||
186 | /// <returns>True if exist, or false.</returns> | ||
187 | override public bool ExistsAsset(UUID uuid) | ||
188 | { | ||
189 | lock (this) { | ||
190 | using (SqliteCommand cmd = new SqliteCommand(SelectAssetSQL, m_conn)) | ||
191 | { | ||
192 | cmd.Parameters.Add(new SqliteParameter(":UUID", uuid.ToString())); | ||
193 | using (IDataReader reader = cmd.ExecuteReader()) | ||
194 | { | ||
195 | if (reader.Read()) | ||
196 | { | ||
197 | reader.Close(); | ||
198 | return true; | ||
199 | } | ||
200 | else | ||
201 | { | ||
202 | reader.Close(); | ||
203 | return false; | ||
204 | } | ||
205 | } | ||
206 | } | ||
207 | } | ||
208 | } | ||
209 | |||
210 | /// <summary> | ||
211 | /// Delete an asset from database | ||
212 | /// </summary> | ||
213 | /// <param name="uuid"></param> | ||
214 | public void DeleteAsset(UUID uuid) | ||
215 | { | ||
216 | using (SqliteCommand cmd = new SqliteCommand(DeleteAssetSQL, m_conn)) | ||
217 | { | ||
218 | cmd.Parameters.Add(new SqliteParameter(":UUID", uuid.ToString())); | ||
219 | |||
220 | cmd.ExecuteNonQuery(); | ||
221 | } | ||
222 | } | ||
223 | |||
224 | /// <summary> | ||
225 | /// | ||
226 | /// </summary> | ||
227 | /// <param name="row"></param> | ||
228 | /// <returns></returns> | ||
229 | private static AssetBase buildAsset(IDataReader row) | ||
230 | { | ||
231 | // TODO: this doesn't work yet because something more | ||
232 | // interesting has to be done to actually get these values | ||
233 | // back out. Not enough time to figure it out yet. | ||
234 | AssetBase asset = new AssetBase( | ||
235 | new UUID((String)row["UUID"]), | ||
236 | (String)row["Name"], | ||
237 | Convert.ToSByte(row["Type"]), | ||
238 | UUID.Zero.ToString() | ||
239 | ); | ||
240 | |||
241 | asset.Description = (String) row["Description"]; | ||
242 | asset.Local = Convert.ToBoolean(row["Local"]); | ||
243 | asset.Temporary = Convert.ToBoolean(row["Temporary"]); | ||
244 | asset.Data = (byte[]) row["Data"]; | ||
245 | return asset; | ||
246 | } | ||
247 | |||
248 | private static AssetMetadata buildAssetMetadata(IDataReader row) | ||
249 | { | ||
250 | AssetMetadata metadata = new AssetMetadata(); | ||
251 | |||
252 | metadata.FullID = new UUID((string) row["UUID"]); | ||
253 | metadata.Name = (string) row["Name"]; | ||
254 | metadata.Description = (string) row["Description"]; | ||
255 | metadata.Type = Convert.ToSByte(row["Type"]); | ||
256 | metadata.Temporary = Convert.ToBoolean(row["Temporary"]); // Not sure if this is correct. | ||
257 | |||
258 | // Current SHA1s are not stored/computed. | ||
259 | metadata.SHA1 = new byte[] {}; | ||
260 | |||
261 | return metadata; | ||
262 | } | ||
263 | |||
264 | /// <summary> | ||
265 | /// Returns a list of AssetMetadata objects. The list is a subset of | ||
266 | /// the entire data set offset by <paramref name="start" /> containing | ||
267 | /// <paramref name="count" /> elements. | ||
268 | /// </summary> | ||
269 | /// <param name="start">The number of results to discard from the total data set.</param> | ||
270 | /// <param name="count">The number of rows the returned list should contain.</param> | ||
271 | /// <returns>A list of AssetMetadata objects.</returns> | ||
272 | public override List<AssetMetadata> FetchAssetMetadataSet(int start, int count) | ||
273 | { | ||
274 | List<AssetMetadata> retList = new List<AssetMetadata>(count); | ||
275 | |||
276 | lock (this) | ||
277 | { | ||
278 | using (SqliteCommand cmd = new SqliteCommand(SelectAssetMetadataSQL, m_conn)) | ||
279 | { | ||
280 | cmd.Parameters.Add(new SqliteParameter(":start", start)); | ||
281 | cmd.Parameters.Add(new SqliteParameter(":count", count)); | ||
282 | |||
283 | using (IDataReader reader = cmd.ExecuteReader()) | ||
284 | { | ||
285 | while (reader.Read()) | ||
286 | { | ||
287 | AssetMetadata metadata = buildAssetMetadata(reader); | ||
288 | retList.Add(metadata); | ||
289 | } | ||
290 | } | ||
291 | } | ||
292 | } | ||
293 | |||
294 | return retList; | ||
295 | } | ||
296 | |||
297 | /*********************************************************************** | ||
298 | * | ||
299 | * Database Binding functions | ||
300 | * | ||
301 | * These will be db specific due to typing, and minor differences | ||
302 | * in databases. | ||
303 | * | ||
304 | **********************************************************************/ | ||
305 | |||
306 | #region IPlugin interface | ||
307 | |||
308 | /// <summary> | ||
309 | /// | ||
310 | /// </summary> | ||
311 | override public string Version | ||
312 | { | ||
313 | get | ||
314 | { | ||
315 | Module module = GetType().Module; | ||
316 | // string dllName = module.Assembly.ManifestModule.Name; | ||
317 | Version dllVersion = module.Assembly.GetName().Version; | ||
318 | |||
319 | return | ||
320 | string.Format("{0}.{1}.{2}.{3}", dllVersion.Major, dllVersion.Minor, dllVersion.Build, | ||
321 | dllVersion.Revision); | ||
322 | } | ||
323 | } | ||
324 | |||
325 | /// <summary> | ||
326 | /// Initialise the AssetData interface using default URI | ||
327 | /// </summary> | ||
328 | override public void Initialise() | ||
329 | { | ||
330 | Initialise("URI=file:Asset.db,version=3"); | ||
331 | } | ||
332 | |||
333 | /// <summary> | ||
334 | /// Name of this DB provider | ||
335 | /// </summary> | ||
336 | override public string Name | ||
337 | { | ||
338 | get { return "SQLite Asset storage engine"; } | ||
339 | } | ||
340 | |||
341 | #endregion | ||
342 | } | ||
343 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteAuthenticationData.cs b/OpenSim/Data/SQLiteNG/SQLiteAuthenticationData.cs new file mode 100644 index 0000000..086ac0a --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteAuthenticationData.cs | |||
@@ -0,0 +1,257 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections; | ||
30 | using System.Collections.Generic; | ||
31 | using System.Data; | ||
32 | using OpenMetaverse; | ||
33 | using OpenSim.Framework; | ||
34 | using Mono.Data.Sqlite; | ||
35 | |||
36 | namespace OpenSim.Data.SQLite | ||
37 | { | ||
38 | public class SQLiteAuthenticationData : SQLiteFramework, IAuthenticationData | ||
39 | { | ||
40 | private string m_Realm; | ||
41 | private List<string> m_ColumnNames; | ||
42 | private int m_LastExpire; | ||
43 | private string m_connectionString; | ||
44 | |||
45 | protected static SqliteConnection m_Connection; | ||
46 | private static bool m_initialized = false; | ||
47 | |||
48 | public SQLiteAuthenticationData(string connectionString, string realm) | ||
49 | : base(connectionString) | ||
50 | { | ||
51 | m_Realm = realm; | ||
52 | m_connectionString = connectionString; | ||
53 | |||
54 | if (!m_initialized) | ||
55 | { | ||
56 | m_Connection = new SqliteConnection(connectionString); | ||
57 | m_Connection.Open(); | ||
58 | |||
59 | Migration m = new Migration(m_Connection, GetType().Assembly, "AuthStore"); | ||
60 | m.Update(); | ||
61 | |||
62 | m_initialized = true; | ||
63 | } | ||
64 | } | ||
65 | |||
66 | public AuthenticationData Get(UUID principalID) | ||
67 | { | ||
68 | AuthenticationData ret = new AuthenticationData(); | ||
69 | ret.Data = new Dictionary<string, object>(); | ||
70 | |||
71 | SqliteCommand cmd = new SqliteCommand("select * from `" + m_Realm + "` where UUID = :PrincipalID"); | ||
72 | cmd.Parameters.Add(new SqliteParameter(":PrincipalID", principalID.ToString())); | ||
73 | |||
74 | IDataReader result = ExecuteReader(cmd, m_Connection); | ||
75 | |||
76 | try | ||
77 | { | ||
78 | if (result.Read()) | ||
79 | { | ||
80 | ret.PrincipalID = principalID; | ||
81 | |||
82 | if (m_ColumnNames == null) | ||
83 | { | ||
84 | m_ColumnNames = new List<string>(); | ||
85 | |||
86 | DataTable schemaTable = result.GetSchemaTable(); | ||
87 | foreach (DataRow row in schemaTable.Rows) | ||
88 | m_ColumnNames.Add(row["ColumnName"].ToString()); | ||
89 | } | ||
90 | |||
91 | foreach (string s in m_ColumnNames) | ||
92 | { | ||
93 | if (s == "UUID") | ||
94 | continue; | ||
95 | |||
96 | ret.Data[s] = result[s].ToString(); | ||
97 | } | ||
98 | |||
99 | return ret; | ||
100 | } | ||
101 | else | ||
102 | { | ||
103 | return null; | ||
104 | } | ||
105 | } | ||
106 | catch | ||
107 | { | ||
108 | } | ||
109 | finally | ||
110 | { | ||
111 | //CloseCommand(cmd); | ||
112 | } | ||
113 | |||
114 | return null; | ||
115 | } | ||
116 | |||
117 | public bool Store(AuthenticationData data) | ||
118 | { | ||
119 | if (data.Data.ContainsKey("UUID")) | ||
120 | data.Data.Remove("UUID"); | ||
121 | |||
122 | string[] fields = new List<string>(data.Data.Keys).ToArray(); | ||
123 | string[] values = new string[data.Data.Count]; | ||
124 | int i = 0; | ||
125 | foreach (object o in data.Data.Values) | ||
126 | values[i++] = o.ToString(); | ||
127 | |||
128 | SqliteCommand cmd = new SqliteCommand(); | ||
129 | |||
130 | if (Get(data.PrincipalID) != null) | ||
131 | { | ||
132 | |||
133 | |||
134 | string update = "update `" + m_Realm + "` set "; | ||
135 | bool first = true; | ||
136 | foreach (string field in fields) | ||
137 | { | ||
138 | if (!first) | ||
139 | update += ", "; | ||
140 | update += "`" + field + "` = :" + field; | ||
141 | cmd.Parameters.Add(new SqliteParameter(":" + field, data.Data[field])); | ||
142 | |||
143 | first = false; | ||
144 | } | ||
145 | |||
146 | update += " where UUID = :UUID"; | ||
147 | cmd.Parameters.Add(new SqliteParameter(":UUID", data.PrincipalID.ToString())); | ||
148 | |||
149 | cmd.CommandText = update; | ||
150 | try | ||
151 | { | ||
152 | if (ExecuteNonQuery(cmd, m_Connection) < 1) | ||
153 | { | ||
154 | //CloseCommand(cmd); | ||
155 | return false; | ||
156 | } | ||
157 | } | ||
158 | catch (Exception e) | ||
159 | { | ||
160 | Console.WriteLine(e.ToString()); | ||
161 | //CloseCommand(cmd); | ||
162 | return false; | ||
163 | } | ||
164 | } | ||
165 | |||
166 | else | ||
167 | { | ||
168 | string insert = "insert into `" + m_Realm + "` (`UUID`, `" + | ||
169 | String.Join("`, `", fields) + | ||
170 | "`) values (:UUID, :" + String.Join(", :", fields) + ")"; | ||
171 | |||
172 | cmd.Parameters.Add(new SqliteParameter(":UUID", data.PrincipalID.ToString())); | ||
173 | foreach (string field in fields) | ||
174 | cmd.Parameters.Add(new SqliteParameter(":" + field, data.Data[field])); | ||
175 | |||
176 | cmd.CommandText = insert; | ||
177 | |||
178 | try | ||
179 | { | ||
180 | if (ExecuteNonQuery(cmd, m_Connection) < 1) | ||
181 | { | ||
182 | //CloseCommand(cmd); | ||
183 | return false; | ||
184 | } | ||
185 | } | ||
186 | catch (Exception e) | ||
187 | { | ||
188 | Console.WriteLine(e.ToString()); | ||
189 | //CloseCommand(cmd); | ||
190 | return false; | ||
191 | } | ||
192 | } | ||
193 | |||
194 | //CloseCommand(cmd); | ||
195 | |||
196 | return true; | ||
197 | } | ||
198 | |||
199 | public bool SetDataItem(UUID principalID, string item, string value) | ||
200 | { | ||
201 | SqliteCommand cmd = new SqliteCommand("update `" + m_Realm + | ||
202 | "` set `" + item + "` = " + value + " where UUID = '" + principalID.ToString() + "'"); | ||
203 | |||
204 | if (ExecuteNonQuery(cmd, m_Connection) > 0) | ||
205 | return true; | ||
206 | |||
207 | return false; | ||
208 | } | ||
209 | |||
210 | public bool SetToken(UUID principalID, string token, int lifetime) | ||
211 | { | ||
212 | if (System.Environment.TickCount - m_LastExpire > 30000) | ||
213 | DoExpire(); | ||
214 | |||
215 | SqliteCommand cmd = new SqliteCommand("insert into tokens (UUID, token, validity) values ('" + principalID.ToString() + | ||
216 | "', '" + token + "', datetime('now', 'localtime', '+" + lifetime.ToString() + " minutes'))"); | ||
217 | |||
218 | if (ExecuteNonQuery(cmd, m_Connection) > 0) | ||
219 | { | ||
220 | cmd.Dispose(); | ||
221 | return true; | ||
222 | } | ||
223 | |||
224 | cmd.Dispose(); | ||
225 | return false; | ||
226 | } | ||
227 | |||
228 | public bool CheckToken(UUID principalID, string token, int lifetime) | ||
229 | { | ||
230 | if (System.Environment.TickCount - m_LastExpire > 30000) | ||
231 | DoExpire(); | ||
232 | |||
233 | SqliteCommand cmd = new SqliteCommand("update tokens set validity = datetime('now', 'localtime', '+" + lifetime.ToString() + | ||
234 | " minutes') where UUID = '" + principalID.ToString() + "' and token = '" + token + "' and validity > datetime('now', 'localtime')"); | ||
235 | |||
236 | if (ExecuteNonQuery(cmd, m_Connection) > 0) | ||
237 | { | ||
238 | cmd.Dispose(); | ||
239 | return true; | ||
240 | } | ||
241 | |||
242 | cmd.Dispose(); | ||
243 | |||
244 | return false; | ||
245 | } | ||
246 | |||
247 | private void DoExpire() | ||
248 | { | ||
249 | SqliteCommand cmd = new SqliteCommand("delete from tokens where validity < datetime('now', 'localtime')"); | ||
250 | ExecuteNonQuery(cmd, m_Connection); | ||
251 | |||
252 | cmd.Dispose(); | ||
253 | |||
254 | m_LastExpire = System.Environment.TickCount; | ||
255 | } | ||
256 | } | ||
257 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteAvatarData.cs b/OpenSim/Data/SQLiteNG/SQLiteAvatarData.cs new file mode 100644 index 0000000..c093884 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteAvatarData.cs | |||
@@ -0,0 +1,74 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Data; | ||
31 | using System.Reflection; | ||
32 | using System.Threading; | ||
33 | using log4net; | ||
34 | using OpenMetaverse; | ||
35 | using OpenSim.Framework; | ||
36 | using Mono.Data.Sqlite; | ||
37 | |||
38 | namespace OpenSim.Data.SQLite | ||
39 | { | ||
40 | /// <summary> | ||
41 | /// A SQLite Interface for Avatar Data | ||
42 | /// </summary> | ||
43 | public class SQLiteAvatarData : SQLiteGenericTableHandler<AvatarBaseData>, | ||
44 | IAvatarData | ||
45 | { | ||
46 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
47 | |||
48 | public SQLiteAvatarData(string connectionString, string realm) : | ||
49 | base(connectionString, realm, "Avatar") | ||
50 | { | ||
51 | } | ||
52 | |||
53 | public bool Delete(UUID principalID, string name) | ||
54 | { | ||
55 | SqliteCommand cmd = new SqliteCommand(); | ||
56 | |||
57 | cmd.CommandText = String.Format("delete from {0} where `PrincipalID` = :PrincipalID and `Name` = :Name", m_Realm); | ||
58 | cmd.Parameters.AddWithValue(":PrincipalID", principalID.ToString()); | ||
59 | cmd.Parameters.AddWithValue(":Name", name); | ||
60 | |||
61 | try | ||
62 | { | ||
63 | if (ExecuteNonQuery(cmd, m_Connection) > 0) | ||
64 | return true; | ||
65 | |||
66 | return false; | ||
67 | } | ||
68 | finally | ||
69 | { | ||
70 | //CloseCommand(cmd); | ||
71 | } | ||
72 | } | ||
73 | } | ||
74 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteEstateData.cs b/OpenSim/Data/SQLiteNG/SQLiteEstateData.cs new file mode 100644 index 0000000..9dd4a2e --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteEstateData.cs | |||
@@ -0,0 +1,387 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Data; | ||
31 | using System.Reflection; | ||
32 | using log4net; | ||
33 | using Mono.Data.Sqlite; | ||
34 | using OpenMetaverse; | ||
35 | using OpenSim.Framework; | ||
36 | using OpenSim.Region.Framework.Interfaces; | ||
37 | |||
38 | namespace OpenSim.Data.SQLite | ||
39 | { | ||
40 | public class SQLiteEstateStore : IEstateDataStore | ||
41 | { | ||
42 | private static readonly ILog m_log = | ||
43 | LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
44 | |||
45 | private SqliteConnection m_connection; | ||
46 | private string m_connectionString; | ||
47 | |||
48 | private FieldInfo[] m_Fields; | ||
49 | private Dictionary<string, FieldInfo> m_FieldMap = | ||
50 | new Dictionary<string, FieldInfo>(); | ||
51 | |||
52 | public void Initialise(string connectionString) | ||
53 | { | ||
54 | m_connectionString = connectionString; | ||
55 | |||
56 | m_log.Info("[ESTATE DB]: Sqlite - connecting: "+m_connectionString); | ||
57 | |||
58 | m_connection = new SqliteConnection(m_connectionString); | ||
59 | m_connection.Open(); | ||
60 | |||
61 | Assembly assem = GetType().Assembly; | ||
62 | Migration m = new Migration(m_connection, assem, "EstateStore"); | ||
63 | m.Update(); | ||
64 | |||
65 | //m_connection.Close(); | ||
66 | // m_connection.Open(); | ||
67 | |||
68 | Type t = typeof(EstateSettings); | ||
69 | m_Fields = t.GetFields(BindingFlags.NonPublic | | ||
70 | BindingFlags.Instance | | ||
71 | BindingFlags.DeclaredOnly); | ||
72 | |||
73 | foreach (FieldInfo f in m_Fields) | ||
74 | if (f.Name.Substring(0, 2) == "m_") | ||
75 | m_FieldMap[f.Name.Substring(2)] = f; | ||
76 | } | ||
77 | |||
78 | private string[] FieldList | ||
79 | { | ||
80 | get { return new List<string>(m_FieldMap.Keys).ToArray(); } | ||
81 | } | ||
82 | |||
83 | public EstateSettings LoadEstateSettings(UUID regionID, bool create) | ||
84 | { | ||
85 | string sql = "select estate_settings."+String.Join(",estate_settings.", FieldList)+" from estate_map left join estate_settings on estate_map.EstateID = estate_settings.EstateID where estate_settings.EstateID is not null and RegionID = :RegionID"; | ||
86 | |||
87 | SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand(); | ||
88 | |||
89 | cmd.CommandText = sql; | ||
90 | cmd.Parameters.AddWithValue(":RegionID", regionID.ToString()); | ||
91 | |||
92 | return DoLoad(cmd, regionID, create); | ||
93 | } | ||
94 | |||
95 | private EstateSettings DoLoad(SqliteCommand cmd, UUID regionID, bool create) | ||
96 | { | ||
97 | EstateSettings es = new EstateSettings(); | ||
98 | es.OnSave += StoreEstateSettings; | ||
99 | |||
100 | IDataReader r = cmd.ExecuteReader(); | ||
101 | |||
102 | if (r.Read()) | ||
103 | { | ||
104 | foreach (string name in FieldList) | ||
105 | { | ||
106 | if (m_FieldMap[name].GetValue(es) is bool) | ||
107 | { | ||
108 | int v = Convert.ToInt32(r[name]); | ||
109 | if (v != 0) | ||
110 | m_FieldMap[name].SetValue(es, true); | ||
111 | else | ||
112 | m_FieldMap[name].SetValue(es, false); | ||
113 | } | ||
114 | else if (m_FieldMap[name].GetValue(es) is UUID) | ||
115 | { | ||
116 | UUID uuid = UUID.Zero; | ||
117 | |||
118 | UUID.TryParse(r[name].ToString(), out uuid); | ||
119 | m_FieldMap[name].SetValue(es, uuid); | ||
120 | } | ||
121 | else | ||
122 | { | ||
123 | m_FieldMap[name].SetValue(es, Convert.ChangeType(r[name], m_FieldMap[name].FieldType)); | ||
124 | } | ||
125 | } | ||
126 | r.Close(); | ||
127 | } | ||
128 | else if (create) | ||
129 | { | ||
130 | r.Close(); | ||
131 | |||
132 | List<string> names = new List<string>(FieldList); | ||
133 | |||
134 | names.Remove("EstateID"); | ||
135 | |||
136 | string sql = "insert into estate_settings ("+String.Join(",", names.ToArray())+") values ( :"+String.Join(", :", names.ToArray())+")"; | ||
137 | |||
138 | cmd.CommandText = sql; | ||
139 | cmd.Parameters.Clear(); | ||
140 | |||
141 | foreach (string name in FieldList) | ||
142 | { | ||
143 | if (m_FieldMap[name].GetValue(es) is bool) | ||
144 | { | ||
145 | if ((bool)m_FieldMap[name].GetValue(es)) | ||
146 | cmd.Parameters.AddWithValue(":"+name, "1"); | ||
147 | else | ||
148 | cmd.Parameters.AddWithValue(":"+name, "0"); | ||
149 | } | ||
150 | else | ||
151 | { | ||
152 | cmd.Parameters.AddWithValue(":"+name, m_FieldMap[name].GetValue(es).ToString()); | ||
153 | } | ||
154 | } | ||
155 | |||
156 | cmd.ExecuteNonQuery(); | ||
157 | |||
158 | cmd.CommandText = "select LAST_INSERT_ROWID() as id"; | ||
159 | cmd.Parameters.Clear(); | ||
160 | |||
161 | r = cmd.ExecuteReader(); | ||
162 | |||
163 | r.Read(); | ||
164 | |||
165 | es.EstateID = Convert.ToUInt32(r["id"]); | ||
166 | |||
167 | r.Close(); | ||
168 | |||
169 | cmd.CommandText = "insert into estate_map values (:RegionID, :EstateID)"; | ||
170 | cmd.Parameters.AddWithValue(":RegionID", regionID.ToString()); | ||
171 | cmd.Parameters.AddWithValue(":EstateID", es.EstateID.ToString()); | ||
172 | |||
173 | // This will throw on dupe key | ||
174 | try | ||
175 | { | ||
176 | cmd.ExecuteNonQuery(); | ||
177 | } | ||
178 | catch (Exception) | ||
179 | { | ||
180 | } | ||
181 | |||
182 | es.Save(); | ||
183 | } | ||
184 | |||
185 | LoadBanList(es); | ||
186 | |||
187 | es.EstateManagers = LoadUUIDList(es.EstateID, "estate_managers"); | ||
188 | es.EstateAccess = LoadUUIDList(es.EstateID, "estate_users"); | ||
189 | es.EstateGroups = LoadUUIDList(es.EstateID, "estate_groups"); | ||
190 | return es; | ||
191 | } | ||
192 | |||
193 | public void StoreEstateSettings(EstateSettings es) | ||
194 | { | ||
195 | List<string> fields = new List<string>(FieldList); | ||
196 | fields.Remove("EstateID"); | ||
197 | |||
198 | List<string> terms = new List<string>(); | ||
199 | |||
200 | foreach (string f in fields) | ||
201 | terms.Add(f+" = :"+f); | ||
202 | |||
203 | string sql = "update estate_settings set "+String.Join(", ", terms.ToArray())+" where EstateID = :EstateID"; | ||
204 | |||
205 | SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand(); | ||
206 | |||
207 | cmd.CommandText = sql; | ||
208 | |||
209 | foreach (string name in FieldList) | ||
210 | { | ||
211 | if (m_FieldMap[name].GetValue(es) is bool) | ||
212 | { | ||
213 | if ((bool)m_FieldMap[name].GetValue(es)) | ||
214 | cmd.Parameters.AddWithValue(":"+name, "1"); | ||
215 | else | ||
216 | cmd.Parameters.AddWithValue(":"+name, "0"); | ||
217 | } | ||
218 | else | ||
219 | { | ||
220 | cmd.Parameters.AddWithValue(":"+name, m_FieldMap[name].GetValue(es).ToString()); | ||
221 | } | ||
222 | } | ||
223 | |||
224 | cmd.ExecuteNonQuery(); | ||
225 | |||
226 | SaveBanList(es); | ||
227 | SaveUUIDList(es.EstateID, "estate_managers", es.EstateManagers); | ||
228 | SaveUUIDList(es.EstateID, "estate_users", es.EstateAccess); | ||
229 | SaveUUIDList(es.EstateID, "estate_groups", es.EstateGroups); | ||
230 | } | ||
231 | |||
232 | private void LoadBanList(EstateSettings es) | ||
233 | { | ||
234 | es.ClearBans(); | ||
235 | |||
236 | SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand(); | ||
237 | |||
238 | cmd.CommandText = "select bannedUUID from estateban where EstateID = :EstateID"; | ||
239 | cmd.Parameters.AddWithValue(":EstateID", es.EstateID); | ||
240 | |||
241 | IDataReader r = cmd.ExecuteReader(); | ||
242 | |||
243 | while (r.Read()) | ||
244 | { | ||
245 | EstateBan eb = new EstateBan(); | ||
246 | |||
247 | UUID uuid = new UUID(); | ||
248 | UUID.TryParse(r["bannedUUID"].ToString(), out uuid); | ||
249 | |||
250 | eb.BannedUserID = uuid; | ||
251 | eb.BannedHostAddress = "0.0.0.0"; | ||
252 | eb.BannedHostIPMask = "0.0.0.0"; | ||
253 | es.AddBan(eb); | ||
254 | } | ||
255 | r.Close(); | ||
256 | } | ||
257 | |||
258 | private void SaveBanList(EstateSettings es) | ||
259 | { | ||
260 | SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand(); | ||
261 | |||
262 | cmd.CommandText = "delete from estateban where EstateID = :EstateID"; | ||
263 | cmd.Parameters.AddWithValue(":EstateID", es.EstateID.ToString()); | ||
264 | |||
265 | cmd.ExecuteNonQuery(); | ||
266 | |||
267 | cmd.Parameters.Clear(); | ||
268 | |||
269 | cmd.CommandText = "insert into estateban (EstateID, bannedUUID, bannedIp, bannedIpHostMask, bannedNameMask) values ( :EstateID, :bannedUUID, '', '', '' )"; | ||
270 | |||
271 | foreach (EstateBan b in es.EstateBans) | ||
272 | { | ||
273 | cmd.Parameters.AddWithValue(":EstateID", es.EstateID.ToString()); | ||
274 | cmd.Parameters.AddWithValue(":bannedUUID", b.BannedUserID.ToString()); | ||
275 | |||
276 | cmd.ExecuteNonQuery(); | ||
277 | cmd.Parameters.Clear(); | ||
278 | } | ||
279 | } | ||
280 | |||
281 | void SaveUUIDList(uint EstateID, string table, UUID[] data) | ||
282 | { | ||
283 | SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand(); | ||
284 | |||
285 | cmd.CommandText = "delete from "+table+" where EstateID = :EstateID"; | ||
286 | cmd.Parameters.AddWithValue(":EstateID", EstateID.ToString()); | ||
287 | |||
288 | cmd.ExecuteNonQuery(); | ||
289 | |||
290 | cmd.Parameters.Clear(); | ||
291 | |||
292 | cmd.CommandText = "insert into "+table+" (EstateID, uuid) values ( :EstateID, :uuid )"; | ||
293 | |||
294 | foreach (UUID uuid in data) | ||
295 | { | ||
296 | cmd.Parameters.AddWithValue(":EstateID", EstateID.ToString()); | ||
297 | cmd.Parameters.AddWithValue(":uuid", uuid.ToString()); | ||
298 | |||
299 | cmd.ExecuteNonQuery(); | ||
300 | cmd.Parameters.Clear(); | ||
301 | } | ||
302 | } | ||
303 | |||
304 | UUID[] LoadUUIDList(uint EstateID, string table) | ||
305 | { | ||
306 | List<UUID> uuids = new List<UUID>(); | ||
307 | |||
308 | SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand(); | ||
309 | |||
310 | cmd.CommandText = "select uuid from "+table+" where EstateID = :EstateID"; | ||
311 | cmd.Parameters.AddWithValue(":EstateID", EstateID); | ||
312 | |||
313 | IDataReader r = cmd.ExecuteReader(); | ||
314 | |||
315 | while (r.Read()) | ||
316 | { | ||
317 | // EstateBan eb = new EstateBan(); | ||
318 | |||
319 | UUID uuid = new UUID(); | ||
320 | UUID.TryParse(r["uuid"].ToString(), out uuid); | ||
321 | |||
322 | uuids.Add(uuid); | ||
323 | } | ||
324 | r.Close(); | ||
325 | |||
326 | return uuids.ToArray(); | ||
327 | } | ||
328 | |||
329 | public EstateSettings LoadEstateSettings(int estateID) | ||
330 | { | ||
331 | string sql = "select estate_settings."+String.Join(",estate_settings.", FieldList)+" from estate_settings where estate_settings.EstateID :EstateID"; | ||
332 | |||
333 | SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand(); | ||
334 | |||
335 | cmd.CommandText = sql; | ||
336 | cmd.Parameters.AddWithValue(":EstateID", estateID.ToString()); | ||
337 | |||
338 | return DoLoad(cmd, UUID.Zero, false); | ||
339 | } | ||
340 | |||
341 | public List<int> GetEstates(string search) | ||
342 | { | ||
343 | List<int> result = new List<int>(); | ||
344 | |||
345 | string sql = "select EstateID from estate_settings where estate_settings.EstateName :EstateName"; | ||
346 | |||
347 | SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand(); | ||
348 | |||
349 | cmd.CommandText = sql; | ||
350 | cmd.Parameters.AddWithValue(":EstateName", search); | ||
351 | |||
352 | IDataReader r = cmd.ExecuteReader(); | ||
353 | |||
354 | while (r.Read()) | ||
355 | { | ||
356 | result.Add(Convert.ToInt32(r["EstateID"])); | ||
357 | } | ||
358 | r.Close(); | ||
359 | |||
360 | return result; | ||
361 | } | ||
362 | |||
363 | public bool LinkRegion(UUID regionID, int estateID) | ||
364 | { | ||
365 | SqliteCommand cmd = (SqliteCommand)m_connection.CreateCommand(); | ||
366 | |||
367 | cmd.CommandText = "insert into estate_map values (:RegionID, :EstateID)"; | ||
368 | cmd.Parameters.AddWithValue(":RegionID", regionID.ToString()); | ||
369 | cmd.Parameters.AddWithValue(":EstateID", estateID.ToString()); | ||
370 | |||
371 | if (cmd.ExecuteNonQuery() == 0) | ||
372 | return false; | ||
373 | |||
374 | return true; | ||
375 | } | ||
376 | |||
377 | public List<UUID> GetRegions(int estateID) | ||
378 | { | ||
379 | return new List<UUID>(); | ||
380 | } | ||
381 | |||
382 | public bool DeleteEstate(int estateID) | ||
383 | { | ||
384 | return false; | ||
385 | } | ||
386 | } | ||
387 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteFramework.cs b/OpenSim/Data/SQLiteNG/SQLiteFramework.cs new file mode 100644 index 0000000..cf114d1 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteFramework.cs | |||
@@ -0,0 +1,95 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections; | ||
30 | using System.Collections.Generic; | ||
31 | using System.Data; | ||
32 | using OpenMetaverse; | ||
33 | using OpenSim.Framework; | ||
34 | using Mono.Data.Sqlite; | ||
35 | |||
36 | namespace OpenSim.Data.SQLite | ||
37 | { | ||
38 | /// <summary> | ||
39 | /// A database interface class to a user profile storage system | ||
40 | /// </summary> | ||
41 | public class SQLiteFramework | ||
42 | { | ||
43 | protected Object m_lockObject = new Object(); | ||
44 | |||
45 | protected SQLiteFramework(string connectionString) | ||
46 | { | ||
47 | } | ||
48 | |||
49 | ////////////////////////////////////////////////////////////// | ||
50 | // | ||
51 | // All non queries are funneled through one connection | ||
52 | // to increase performance a little | ||
53 | // | ||
54 | protected int ExecuteNonQuery(SqliteCommand cmd, SqliteConnection connection) | ||
55 | { | ||
56 | lock (connection) | ||
57 | { | ||
58 | /* | ||
59 | SqliteConnection newConnection = | ||
60 | (SqliteConnection)((ICloneable)connection).Clone(); | ||
61 | newConnection.Open(); | ||
62 | |||
63 | cmd.Connection = newConnection; | ||
64 | */ | ||
65 | cmd.Connection = connection; | ||
66 | //Console.WriteLine("XXX " + cmd.CommandText); | ||
67 | |||
68 | return cmd.ExecuteNonQuery(); | ||
69 | } | ||
70 | } | ||
71 | |||
72 | protected IDataReader ExecuteReader(SqliteCommand cmd, SqliteConnection connection) | ||
73 | { | ||
74 | lock (connection) | ||
75 | { | ||
76 | //SqliteConnection newConnection = | ||
77 | // (SqliteConnection)((ICloneable)connection).Clone(); | ||
78 | //newConnection.Open(); | ||
79 | |||
80 | //cmd.Connection = newConnection; | ||
81 | cmd.Connection = connection; | ||
82 | //Console.WriteLine("XXX " + cmd.CommandText); | ||
83 | |||
84 | return cmd.ExecuteReader(); | ||
85 | } | ||
86 | } | ||
87 | |||
88 | protected void CloseCommand(SqliteCommand cmd) | ||
89 | { | ||
90 | cmd.Connection.Close(); | ||
91 | cmd.Connection.Dispose(); | ||
92 | cmd.Dispose(); | ||
93 | } | ||
94 | } | ||
95 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteFriendsData.cs b/OpenSim/Data/SQLiteNG/SQLiteFriendsData.cs new file mode 100644 index 0000000..b06853c --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteFriendsData.cs | |||
@@ -0,0 +1,70 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections; | ||
30 | using System.Collections.Generic; | ||
31 | using System.Data; | ||
32 | using OpenMetaverse; | ||
33 | using OpenSim.Framework; | ||
34 | using Mono.Data.Sqlite; | ||
35 | |||
36 | namespace OpenSim.Data.SQLite | ||
37 | { | ||
38 | public class SQLiteFriendsData : SQLiteGenericTableHandler<FriendsData>, IFriendsData | ||
39 | { | ||
40 | public SQLiteFriendsData(string connectionString, string realm) | ||
41 | : base(connectionString, realm, "FriendsStore") | ||
42 | { | ||
43 | } | ||
44 | |||
45 | public FriendsData[] GetFriends(UUID userID) | ||
46 | { | ||
47 | SqliteCommand cmd = new SqliteCommand(); | ||
48 | |||
49 | cmd.CommandText = String.Format("select a.*,case when b.Flags is null then -1 else b.Flags end as TheirFlags from {0} as a left join {0} as b on a.PrincipalID = b.Friend and a.Friend = b.PrincipalID where a.PrincipalID = :PrincipalID", m_Realm); | ||
50 | cmd.Parameters.AddWithValue(":PrincipalID", userID.ToString()); | ||
51 | |||
52 | return DoQuery(cmd); | ||
53 | |||
54 | } | ||
55 | |||
56 | public bool Delete(UUID principalID, string friend) | ||
57 | { | ||
58 | SqliteCommand cmd = new SqliteCommand(); | ||
59 | |||
60 | cmd.CommandText = String.Format("delete from {0} where PrincipalID = :PrincipalID and Friend = :Friend", m_Realm); | ||
61 | cmd.Parameters.AddWithValue(":PrincipalID", principalID.ToString()); | ||
62 | cmd.Parameters.AddWithValue(":Friend", friend); | ||
63 | |||
64 | ExecuteNonQuery(cmd, cmd.Connection); | ||
65 | |||
66 | return true; | ||
67 | } | ||
68 | |||
69 | } | ||
70 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteGenericTableHandler.cs b/OpenSim/Data/SQLiteNG/SQLiteGenericTableHandler.cs new file mode 100644 index 0000000..3c70aef --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteGenericTableHandler.cs | |||
@@ -0,0 +1,270 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Data; | ||
31 | using System.Reflection; | ||
32 | using log4net; | ||
33 | using Mono.Data.Sqlite; | ||
34 | using OpenMetaverse; | ||
35 | using OpenSim.Framework; | ||
36 | using OpenSim.Region.Framework.Interfaces; | ||
37 | |||
38 | namespace OpenSim.Data.SQLite | ||
39 | { | ||
40 | public class SQLiteGenericTableHandler<T> : SQLiteFramework where T: class, new() | ||
41 | { | ||
42 | // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
43 | |||
44 | protected Dictionary<string, FieldInfo> m_Fields = | ||
45 | new Dictionary<string, FieldInfo>(); | ||
46 | |||
47 | protected List<string> m_ColumnNames = null; | ||
48 | protected string m_Realm; | ||
49 | protected FieldInfo m_DataField = null; | ||
50 | |||
51 | protected static SqliteConnection m_Connection; | ||
52 | private static bool m_initialized; | ||
53 | |||
54 | public SQLiteGenericTableHandler(string connectionString, | ||
55 | string realm, string storeName) : base(connectionString) | ||
56 | { | ||
57 | m_Realm = realm; | ||
58 | |||
59 | if (!m_initialized) | ||
60 | { | ||
61 | m_Connection = new SqliteConnection(connectionString); | ||
62 | Console.WriteLine(string.Format("OPENING CONNECTION FOR {0} USING {1}", storeName, connectionString)); | ||
63 | m_Connection.Open(); | ||
64 | |||
65 | if (storeName != String.Empty) | ||
66 | { | ||
67 | Assembly assem = GetType().Assembly; | ||
68 | //SqliteConnection newConnection = | ||
69 | // (SqliteConnection)((ICloneable)m_Connection).Clone(); | ||
70 | //newConnection.Open(); | ||
71 | |||
72 | //Migration m = new Migration(newConnection, assem, storeName); | ||
73 | Migration m = new Migration(m_Connection, assem, storeName); | ||
74 | m.Update(); | ||
75 | //newConnection.Close(); | ||
76 | //newConnection.Dispose(); | ||
77 | } | ||
78 | |||
79 | m_initialized = true; | ||
80 | } | ||
81 | |||
82 | Type t = typeof(T); | ||
83 | FieldInfo[] fields = t.GetFields(BindingFlags.Public | | ||
84 | BindingFlags.Instance | | ||
85 | BindingFlags.DeclaredOnly); | ||
86 | |||
87 | if (fields.Length == 0) | ||
88 | return; | ||
89 | |||
90 | foreach (FieldInfo f in fields) | ||
91 | { | ||
92 | if (f.Name != "Data") | ||
93 | m_Fields[f.Name] = f; | ||
94 | else | ||
95 | m_DataField = f; | ||
96 | } | ||
97 | } | ||
98 | |||
99 | private void CheckColumnNames(IDataReader reader) | ||
100 | { | ||
101 | if (m_ColumnNames != null) | ||
102 | return; | ||
103 | |||
104 | m_ColumnNames = new List<string>(); | ||
105 | |||
106 | DataTable schemaTable = reader.GetSchemaTable(); | ||
107 | foreach (DataRow row in schemaTable.Rows) | ||
108 | { | ||
109 | if (row["ColumnName"] != null && | ||
110 | (!m_Fields.ContainsKey(row["ColumnName"].ToString()))) | ||
111 | m_ColumnNames.Add(row["ColumnName"].ToString()); | ||
112 | } | ||
113 | } | ||
114 | |||
115 | public T[] Get(string field, string key) | ||
116 | { | ||
117 | return Get(new string[] { field }, new string[] { key }); | ||
118 | } | ||
119 | |||
120 | public T[] Get(string[] fields, string[] keys) | ||
121 | { | ||
122 | if (fields.Length != keys.Length) | ||
123 | return new T[0]; | ||
124 | |||
125 | List<string> terms = new List<string>(); | ||
126 | |||
127 | SqliteCommand cmd = new SqliteCommand(); | ||
128 | |||
129 | for (int i = 0 ; i < fields.Length ; i++) | ||
130 | { | ||
131 | cmd.Parameters.Add(new SqliteParameter(":" + fields[i], keys[i])); | ||
132 | terms.Add("`" + fields[i] + "` = :" + fields[i]); | ||
133 | } | ||
134 | |||
135 | string where = String.Join(" and ", terms.ToArray()); | ||
136 | |||
137 | string query = String.Format("select * from {0} where {1}", | ||
138 | m_Realm, where); | ||
139 | |||
140 | cmd.CommandText = query; | ||
141 | |||
142 | return DoQuery(cmd); | ||
143 | } | ||
144 | |||
145 | protected T[] DoQuery(SqliteCommand cmd) | ||
146 | { | ||
147 | IDataReader reader = ExecuteReader(cmd, m_Connection); | ||
148 | if (reader == null) | ||
149 | return new T[0]; | ||
150 | |||
151 | CheckColumnNames(reader); | ||
152 | |||
153 | List<T> result = new List<T>(); | ||
154 | |||
155 | while (reader.Read()) | ||
156 | { | ||
157 | T row = new T(); | ||
158 | |||
159 | foreach (string name in m_Fields.Keys) | ||
160 | { | ||
161 | if (m_Fields[name].GetValue(row) is bool) | ||
162 | { | ||
163 | int v = Convert.ToInt32(reader[name]); | ||
164 | m_Fields[name].SetValue(row, v != 0 ? true : false); | ||
165 | } | ||
166 | else if (m_Fields[name].GetValue(row) is UUID) | ||
167 | { | ||
168 | UUID uuid = UUID.Zero; | ||
169 | |||
170 | UUID.TryParse(reader[name].ToString(), out uuid); | ||
171 | m_Fields[name].SetValue(row, uuid); | ||
172 | } | ||
173 | else if (m_Fields[name].GetValue(row) is int) | ||
174 | { | ||
175 | int v = Convert.ToInt32(reader[name]); | ||
176 | m_Fields[name].SetValue(row, v); | ||
177 | } | ||
178 | else | ||
179 | { | ||
180 | m_Fields[name].SetValue(row, reader[name]); | ||
181 | } | ||
182 | } | ||
183 | |||
184 | if (m_DataField != null) | ||
185 | { | ||
186 | Dictionary<string, string> data = | ||
187 | new Dictionary<string, string>(); | ||
188 | |||
189 | foreach (string col in m_ColumnNames) | ||
190 | { | ||
191 | data[col] = reader[col].ToString(); | ||
192 | if (data[col] == null) | ||
193 | data[col] = String.Empty; | ||
194 | } | ||
195 | |||
196 | m_DataField.SetValue(row, data); | ||
197 | } | ||
198 | |||
199 | result.Add(row); | ||
200 | } | ||
201 | |||
202 | //CloseCommand(cmd); | ||
203 | |||
204 | return result.ToArray(); | ||
205 | } | ||
206 | |||
207 | public T[] Get(string where) | ||
208 | { | ||
209 | SqliteCommand cmd = new SqliteCommand(); | ||
210 | |||
211 | string query = String.Format("select * from {0} where {1}", | ||
212 | m_Realm, where); | ||
213 | |||
214 | cmd.CommandText = query; | ||
215 | |||
216 | return DoQuery(cmd); | ||
217 | } | ||
218 | |||
219 | public bool Store(T row) | ||
220 | { | ||
221 | SqliteCommand cmd = new SqliteCommand(); | ||
222 | |||
223 | string query = ""; | ||
224 | List<String> names = new List<String>(); | ||
225 | List<String> values = new List<String>(); | ||
226 | |||
227 | foreach (FieldInfo fi in m_Fields.Values) | ||
228 | { | ||
229 | names.Add(fi.Name); | ||
230 | values.Add(":" + fi.Name); | ||
231 | cmd.Parameters.Add(new SqliteParameter(":" + fi.Name, fi.GetValue(row).ToString())); | ||
232 | } | ||
233 | |||
234 | if (m_DataField != null) | ||
235 | { | ||
236 | Dictionary<string, string> data = | ||
237 | (Dictionary<string, string>)m_DataField.GetValue(row); | ||
238 | |||
239 | foreach (KeyValuePair<string, string> kvp in data) | ||
240 | { | ||
241 | names.Add(kvp.Key); | ||
242 | values.Add(":" + kvp.Key); | ||
243 | cmd.Parameters.Add(new SqliteParameter(":" + kvp.Key, kvp.Value)); | ||
244 | } | ||
245 | } | ||
246 | |||
247 | query = String.Format("replace into {0} (`", m_Realm) + String.Join("`,`", names.ToArray()) + "`) values (" + String.Join(",", values.ToArray()) + ")"; | ||
248 | |||
249 | cmd.CommandText = query; | ||
250 | |||
251 | if (ExecuteNonQuery(cmd, m_Connection) > 0) | ||
252 | return true; | ||
253 | |||
254 | return false; | ||
255 | } | ||
256 | |||
257 | public bool Delete(string field, string val) | ||
258 | { | ||
259 | SqliteCommand cmd = new SqliteCommand(); | ||
260 | |||
261 | cmd.CommandText = String.Format("delete from {0} where `{1}` = :{1}", m_Realm, field); | ||
262 | cmd.Parameters.Add(new SqliteParameter(field, val)); | ||
263 | |||
264 | if (ExecuteNonQuery(cmd, m_Connection) > 0) | ||
265 | return true; | ||
266 | |||
267 | return false; | ||
268 | } | ||
269 | } | ||
270 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteInventoryStore.cs b/OpenSim/Data/SQLiteNG/SQLiteInventoryStore.cs new file mode 100644 index 0000000..ece2495 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteInventoryStore.cs | |||
@@ -0,0 +1,909 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Data; | ||
31 | using System.Reflection; | ||
32 | using log4net; | ||
33 | using Mono.Data.Sqlite; | ||
34 | using OpenMetaverse; | ||
35 | using OpenSim.Framework; | ||
36 | |||
37 | namespace OpenSim.Data.SQLite | ||
38 | { | ||
39 | /// <summary> | ||
40 | /// An Inventory Interface to the SQLite database | ||
41 | /// </summary> | ||
42 | public class SQLiteInventoryStore : SQLiteUtil, IInventoryDataPlugin | ||
43 | { | ||
44 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
45 | |||
46 | private const string invItemsSelect = "select * from inventoryitems"; | ||
47 | private const string invFoldersSelect = "select * from inventoryfolders"; | ||
48 | |||
49 | private static SqliteConnection conn; | ||
50 | private static DataSet ds; | ||
51 | private static SqliteDataAdapter invItemsDa; | ||
52 | private static SqliteDataAdapter invFoldersDa; | ||
53 | |||
54 | private static bool m_Initialized = false; | ||
55 | |||
56 | public void Initialise() | ||
57 | { | ||
58 | m_log.Info("[SQLiteInventoryData]: " + Name + " cannot be default-initialized!"); | ||
59 | throw new PluginNotInitialisedException(Name); | ||
60 | } | ||
61 | |||
62 | /// <summary> | ||
63 | /// <list type="bullet"> | ||
64 | /// <item>Initialises Inventory interface</item> | ||
65 | /// <item>Loads and initialises a new SQLite connection and maintains it.</item> | ||
66 | /// <item>use default URI if connect string string is empty.</item> | ||
67 | /// </list> | ||
68 | /// </summary> | ||
69 | /// <param name="dbconnect">connect string</param> | ||
70 | public void Initialise(string dbconnect) | ||
71 | { | ||
72 | if (!m_Initialized) | ||
73 | { | ||
74 | m_Initialized = true; | ||
75 | |||
76 | if (dbconnect == string.Empty) | ||
77 | { | ||
78 | dbconnect = "URI=file:inventoryStore.db,version=3"; | ||
79 | } | ||
80 | m_log.Info("[INVENTORY DB]: Sqlite - connecting: " + dbconnect); | ||
81 | conn = new SqliteConnection(dbconnect); | ||
82 | |||
83 | conn.Open(); | ||
84 | |||
85 | Assembly assem = GetType().Assembly; | ||
86 | Migration m = new Migration(conn, assem, "InventoryStore"); | ||
87 | m.Update(); | ||
88 | |||
89 | SqliteCommand itemsSelectCmd = new SqliteCommand(invItemsSelect, conn); | ||
90 | invItemsDa = new SqliteDataAdapter(itemsSelectCmd); | ||
91 | // SqliteCommandBuilder primCb = new SqliteCommandBuilder(primDa); | ||
92 | |||
93 | SqliteCommand foldersSelectCmd = new SqliteCommand(invFoldersSelect, conn); | ||
94 | invFoldersDa = new SqliteDataAdapter(foldersSelectCmd); | ||
95 | |||
96 | ds = new DataSet(); | ||
97 | |||
98 | ds.Tables.Add(createInventoryFoldersTable()); | ||
99 | invFoldersDa.Fill(ds.Tables["inventoryfolders"]); | ||
100 | setupFoldersCommands(invFoldersDa, conn); | ||
101 | CreateDataSetMapping(invFoldersDa, "inventoryfolders"); | ||
102 | m_log.Info("[INVENTORY DB]: Populated Inventory Folders Definitions"); | ||
103 | |||
104 | ds.Tables.Add(createInventoryItemsTable()); | ||
105 | invItemsDa.Fill(ds.Tables["inventoryitems"]); | ||
106 | setupItemsCommands(invItemsDa, conn); | ||
107 | CreateDataSetMapping(invItemsDa, "inventoryitems"); | ||
108 | m_log.Info("[INVENTORY DB]: Populated Inventory Items Definitions"); | ||
109 | |||
110 | ds.AcceptChanges(); | ||
111 | } | ||
112 | } | ||
113 | |||
114 | /// <summary> | ||
115 | /// Closes the inventory interface | ||
116 | /// </summary> | ||
117 | public void Dispose() | ||
118 | { | ||
119 | if (conn != null) | ||
120 | { | ||
121 | conn.Close(); | ||
122 | conn = null; | ||
123 | } | ||
124 | if (invItemsDa != null) | ||
125 | { | ||
126 | invItemsDa.Dispose(); | ||
127 | invItemsDa = null; | ||
128 | } | ||
129 | if (invFoldersDa != null) | ||
130 | { | ||
131 | invFoldersDa.Dispose(); | ||
132 | invFoldersDa = null; | ||
133 | } | ||
134 | if (ds != null) | ||
135 | { | ||
136 | ds.Dispose(); | ||
137 | ds = null; | ||
138 | } | ||
139 | } | ||
140 | |||
141 | /// <summary> | ||
142 | /// | ||
143 | /// </summary> | ||
144 | /// <param name="row"></param> | ||
145 | /// <returns></returns> | ||
146 | public InventoryItemBase buildItem(DataRow row) | ||
147 | { | ||
148 | InventoryItemBase item = new InventoryItemBase(); | ||
149 | item.ID = new UUID((string) row["UUID"]); | ||
150 | item.AssetID = new UUID((string) row["assetID"]); | ||
151 | item.AssetType = Convert.ToInt32(row["assetType"]); | ||
152 | item.InvType = Convert.ToInt32(row["invType"]); | ||
153 | item.Folder = new UUID((string) row["parentFolderID"]); | ||
154 | item.Owner = new UUID((string) row["avatarID"]); | ||
155 | item.CreatorId = (string)row["creatorsID"]; | ||
156 | item.Name = (string) row["inventoryName"]; | ||
157 | item.Description = (string) row["inventoryDescription"]; | ||
158 | |||
159 | item.NextPermissions = Convert.ToUInt32(row["inventoryNextPermissions"]); | ||
160 | item.CurrentPermissions = Convert.ToUInt32(row["inventoryCurrentPermissions"]); | ||
161 | item.BasePermissions = Convert.ToUInt32(row["inventoryBasePermissions"]); | ||
162 | item.EveryOnePermissions = Convert.ToUInt32(row["inventoryEveryOnePermissions"]); | ||
163 | item.GroupPermissions = Convert.ToUInt32(row["inventoryGroupPermissions"]); | ||
164 | |||
165 | // new fields | ||
166 | if (!Convert.IsDBNull(row["salePrice"])) | ||
167 | item.SalePrice = Convert.ToInt32(row["salePrice"]); | ||
168 | |||
169 | if (!Convert.IsDBNull(row["saleType"])) | ||
170 | item.SaleType = Convert.ToByte(row["saleType"]); | ||
171 | |||
172 | if (!Convert.IsDBNull(row["creationDate"])) | ||
173 | item.CreationDate = Convert.ToInt32(row["creationDate"]); | ||
174 | |||
175 | if (!Convert.IsDBNull(row["groupID"])) | ||
176 | item.GroupID = new UUID((string)row["groupID"]); | ||
177 | |||
178 | if (!Convert.IsDBNull(row["groupOwned"])) | ||
179 | item.GroupOwned = Convert.ToBoolean(row["groupOwned"]); | ||
180 | |||
181 | if (!Convert.IsDBNull(row["Flags"])) | ||
182 | item.Flags = Convert.ToUInt32(row["Flags"]); | ||
183 | |||
184 | return item; | ||
185 | } | ||
186 | |||
187 | /// <summary> | ||
188 | /// Fill a database row with item data | ||
189 | /// </summary> | ||
190 | /// <param name="row"></param> | ||
191 | /// <param name="item"></param> | ||
192 | private static void fillItemRow(DataRow row, InventoryItemBase item) | ||
193 | { | ||
194 | row["UUID"] = item.ID.ToString(); | ||
195 | row["assetID"] = item.AssetID.ToString(); | ||
196 | row["assetType"] = item.AssetType; | ||
197 | row["invType"] = item.InvType; | ||
198 | row["parentFolderID"] = item.Folder.ToString(); | ||
199 | row["avatarID"] = item.Owner.ToString(); | ||
200 | row["creatorsID"] = item.CreatorId.ToString(); | ||
201 | row["inventoryName"] = item.Name; | ||
202 | row["inventoryDescription"] = item.Description; | ||
203 | |||
204 | row["inventoryNextPermissions"] = item.NextPermissions; | ||
205 | row["inventoryCurrentPermissions"] = item.CurrentPermissions; | ||
206 | row["inventoryBasePermissions"] = item.BasePermissions; | ||
207 | row["inventoryEveryOnePermissions"] = item.EveryOnePermissions; | ||
208 | row["inventoryGroupPermissions"] = item.GroupPermissions; | ||
209 | |||
210 | // new fields | ||
211 | row["salePrice"] = item.SalePrice; | ||
212 | row["saleType"] = item.SaleType; | ||
213 | row["creationDate"] = item.CreationDate; | ||
214 | row["groupID"] = item.GroupID.ToString(); | ||
215 | row["groupOwned"] = item.GroupOwned; | ||
216 | row["flags"] = item.Flags; | ||
217 | } | ||
218 | |||
219 | /// <summary> | ||
220 | /// Add inventory folder | ||
221 | /// </summary> | ||
222 | /// <param name="folder">Folder base</param> | ||
223 | /// <param name="add">true=create folder. false=update existing folder</param> | ||
224 | /// <remarks>nasty</remarks> | ||
225 | private void addFolder(InventoryFolderBase folder, bool add) | ||
226 | { | ||
227 | lock (ds) | ||
228 | { | ||
229 | DataTable inventoryFolderTable = ds.Tables["inventoryfolders"]; | ||
230 | |||
231 | DataRow inventoryRow = inventoryFolderTable.Rows.Find(folder.ID.ToString()); | ||
232 | if (inventoryRow == null) | ||
233 | { | ||
234 | if (! add) | ||
235 | m_log.ErrorFormat("Interface Misuse: Attempting to Update non-existant inventory folder: {0}", folder.ID); | ||
236 | |||
237 | inventoryRow = inventoryFolderTable.NewRow(); | ||
238 | fillFolderRow(inventoryRow, folder); | ||
239 | inventoryFolderTable.Rows.Add(inventoryRow); | ||
240 | } | ||
241 | else | ||
242 | { | ||
243 | if (add) | ||
244 | m_log.ErrorFormat("Interface Misuse: Attempting to Add inventory folder that already exists: {0}", folder.ID); | ||
245 | |||
246 | fillFolderRow(inventoryRow, folder); | ||
247 | } | ||
248 | |||
249 | invFoldersDa.Update(ds, "inventoryfolders"); | ||
250 | } | ||
251 | } | ||
252 | |||
253 | /// <summary> | ||
254 | /// Move an inventory folder | ||
255 | /// </summary> | ||
256 | /// <param name="folder">folder base</param> | ||
257 | private void moveFolder(InventoryFolderBase folder) | ||
258 | { | ||
259 | lock (ds) | ||
260 | { | ||
261 | DataTable inventoryFolderTable = ds.Tables["inventoryfolders"]; | ||
262 | |||
263 | DataRow inventoryRow = inventoryFolderTable.Rows.Find(folder.ID.ToString()); | ||
264 | if (inventoryRow == null) | ||
265 | { | ||
266 | inventoryRow = inventoryFolderTable.NewRow(); | ||
267 | fillFolderRow(inventoryRow, folder); | ||
268 | inventoryFolderTable.Rows.Add(inventoryRow); | ||
269 | } | ||
270 | else | ||
271 | { | ||
272 | moveFolderRow(inventoryRow, folder); | ||
273 | } | ||
274 | |||
275 | invFoldersDa.Update(ds, "inventoryfolders"); | ||
276 | } | ||
277 | } | ||
278 | |||
279 | /// <summary> | ||
280 | /// add an item in inventory | ||
281 | /// </summary> | ||
282 | /// <param name="item">the item</param> | ||
283 | /// <param name="add">true=add item ; false=update existing item</param> | ||
284 | private void addItem(InventoryItemBase item, bool add) | ||
285 | { | ||
286 | lock (ds) | ||
287 | { | ||
288 | DataTable inventoryItemTable = ds.Tables["inventoryitems"]; | ||
289 | |||
290 | DataRow inventoryRow = inventoryItemTable.Rows.Find(item.ID.ToString()); | ||
291 | if (inventoryRow == null) | ||
292 | { | ||
293 | if (!add) | ||
294 | m_log.ErrorFormat("[INVENTORY DB]: Interface Misuse: Attempting to Update non-existant inventory item: {0}", item.ID); | ||
295 | |||
296 | inventoryRow = inventoryItemTable.NewRow(); | ||
297 | fillItemRow(inventoryRow, item); | ||
298 | inventoryItemTable.Rows.Add(inventoryRow); | ||
299 | } | ||
300 | else | ||
301 | { | ||
302 | if (add) | ||
303 | m_log.ErrorFormat("[INVENTORY DB]: Interface Misuse: Attempting to Add inventory item that already exists: {0}", item.ID); | ||
304 | |||
305 | fillItemRow(inventoryRow, item); | ||
306 | } | ||
307 | |||
308 | invItemsDa.Update(ds, "inventoryitems"); | ||
309 | |||
310 | DataTable inventoryFolderTable = ds.Tables["inventoryfolders"]; | ||
311 | |||
312 | inventoryRow = inventoryFolderTable.Rows.Find(item.Folder.ToString()); | ||
313 | if (inventoryRow != null) //MySQL doesn't throw an exception here, so sqlite shouldn't either. | ||
314 | inventoryRow["version"] = (int)inventoryRow["version"] + 1; | ||
315 | |||
316 | invFoldersDa.Update(ds, "inventoryfolders"); | ||
317 | } | ||
318 | } | ||
319 | |||
320 | /// <summary> | ||
321 | /// TODO : DataSet commit | ||
322 | /// </summary> | ||
323 | public void Shutdown() | ||
324 | { | ||
325 | // TODO: DataSet commit | ||
326 | } | ||
327 | |||
328 | /// <summary> | ||
329 | /// The name of this DB provider | ||
330 | /// </summary> | ||
331 | /// <returns>Name of DB provider</returns> | ||
332 | public string Name | ||
333 | { | ||
334 | get { return "SQLite Inventory Data Interface"; } | ||
335 | } | ||
336 | |||
337 | /// <summary> | ||
338 | /// Returns the version of this DB provider | ||
339 | /// </summary> | ||
340 | /// <returns>A string containing the DB provider version</returns> | ||
341 | public string Version | ||
342 | { | ||
343 | get | ||
344 | { | ||
345 | Module module = GetType().Module; | ||
346 | // string dllName = module.Assembly.ManifestModule.Name; | ||
347 | Version dllVersion = module.Assembly.GetName().Version; | ||
348 | |||
349 | |||
350 | return | ||
351 | string.Format("{0}.{1}.{2}.{3}", dllVersion.Major, dllVersion.Minor, dllVersion.Build, | ||
352 | dllVersion.Revision); | ||
353 | } | ||
354 | } | ||
355 | |||
356 | /// <summary> | ||
357 | /// Returns a list of inventory items contained within the specified folder | ||
358 | /// </summary> | ||
359 | /// <param name="folderID">The UUID of the target folder</param> | ||
360 | /// <returns>A List of InventoryItemBase items</returns> | ||
361 | public List<InventoryItemBase> getInventoryInFolder(UUID folderID) | ||
362 | { | ||
363 | lock (ds) | ||
364 | { | ||
365 | List<InventoryItemBase> retval = new List<InventoryItemBase>(); | ||
366 | DataTable inventoryItemTable = ds.Tables["inventoryitems"]; | ||
367 | string selectExp = "parentFolderID = '" + folderID + "'"; | ||
368 | DataRow[] rows = inventoryItemTable.Select(selectExp); | ||
369 | foreach (DataRow row in rows) | ||
370 | { | ||
371 | retval.Add(buildItem(row)); | ||
372 | } | ||
373 | |||
374 | return retval; | ||
375 | } | ||
376 | } | ||
377 | |||
378 | /// <summary> | ||
379 | /// Returns a list of the root folders within a users inventory | ||
380 | /// </summary> | ||
381 | /// <param name="user">The user whos inventory is to be searched</param> | ||
382 | /// <returns>A list of folder objects</returns> | ||
383 | public List<InventoryFolderBase> getUserRootFolders(UUID user) | ||
384 | { | ||
385 | return new List<InventoryFolderBase>(); | ||
386 | } | ||
387 | |||
388 | // see InventoryItemBase.getUserRootFolder | ||
389 | public InventoryFolderBase getUserRootFolder(UUID user) | ||
390 | { | ||
391 | lock (ds) | ||
392 | { | ||
393 | List<InventoryFolderBase> folders = new List<InventoryFolderBase>(); | ||
394 | DataTable inventoryFolderTable = ds.Tables["inventoryfolders"]; | ||
395 | string selectExp = "agentID = '" + user + "' AND parentID = '" + UUID.Zero + "'"; | ||
396 | DataRow[] rows = inventoryFolderTable.Select(selectExp); | ||
397 | foreach (DataRow row in rows) | ||
398 | { | ||
399 | folders.Add(buildFolder(row)); | ||
400 | } | ||
401 | |||
402 | // There should only ever be one root folder for a user. However, if there's more | ||
403 | // than one we'll simply use the first one rather than failing. It would be even | ||
404 | // nicer to print some message to this effect, but this feels like it's too low a | ||
405 | // to put such a message out, and it's too minor right now to spare the time to | ||
406 | // suitably refactor. | ||
407 | if (folders.Count > 0) | ||
408 | { | ||
409 | return folders[0]; | ||
410 | } | ||
411 | |||
412 | return null; | ||
413 | } | ||
414 | } | ||
415 | |||
416 | /// <summary> | ||
417 | /// Append a list of all the child folders of a parent folder | ||
418 | /// </summary> | ||
419 | /// <param name="folders">list where folders will be appended</param> | ||
420 | /// <param name="parentID">ID of parent</param> | ||
421 | protected void getInventoryFolders(ref List<InventoryFolderBase> folders, UUID parentID) | ||
422 | { | ||
423 | lock (ds) | ||
424 | { | ||
425 | DataTable inventoryFolderTable = ds.Tables["inventoryfolders"]; | ||
426 | string selectExp = "parentID = '" + parentID + "'"; | ||
427 | DataRow[] rows = inventoryFolderTable.Select(selectExp); | ||
428 | foreach (DataRow row in rows) | ||
429 | { | ||
430 | folders.Add(buildFolder(row)); | ||
431 | } | ||
432 | |||
433 | } | ||
434 | } | ||
435 | |||
436 | /// <summary> | ||
437 | /// Returns a list of inventory folders contained in the folder 'parentID' | ||
438 | /// </summary> | ||
439 | /// <param name="parentID">The folder to get subfolders for</param> | ||
440 | /// <returns>A list of inventory folders</returns> | ||
441 | public List<InventoryFolderBase> getInventoryFolders(UUID parentID) | ||
442 | { | ||
443 | List<InventoryFolderBase> folders = new List<InventoryFolderBase>(); | ||
444 | getInventoryFolders(ref folders, parentID); | ||
445 | return folders; | ||
446 | } | ||
447 | |||
448 | /// <summary> | ||
449 | /// See IInventoryDataPlugin | ||
450 | /// </summary> | ||
451 | /// <param name="parentID"></param> | ||
452 | /// <returns></returns> | ||
453 | public List<InventoryFolderBase> getFolderHierarchy(UUID parentID) | ||
454 | { | ||
455 | /* Note: There are subtle changes between this implementation of getFolderHierarchy and the previous one | ||
456 | * - We will only need to hit the database twice instead of n times. | ||
457 | * - We assume the database is well-formed - no stranded/dangling folders, all folders in heirarchy owned | ||
458 | * by the same person, each user only has 1 inventory heirarchy | ||
459 | * - The returned list is not ordered, instead of breadth-first ordered | ||
460 | There are basically 2 usage cases for getFolderHeirarchy: | ||
461 | 1) Getting the user's entire inventory heirarchy when they log in | ||
462 | 2) Finding a subfolder heirarchy to delete when emptying the trash. | ||
463 | This implementation will pull all inventory folders from the database, and then prune away any folder that | ||
464 | is not part of the requested sub-heirarchy. The theory is that it is cheaper to make 1 request from the | ||
465 | database than to make n requests. This pays off only if requested heirarchy is large. | ||
466 | By making this choice, we are making the worst case better at the cost of making the best case worse | ||
467 | - Francis | ||
468 | */ | ||
469 | |||
470 | List<InventoryFolderBase> folders = new List<InventoryFolderBase>(); | ||
471 | DataRow[] folderRows = null, parentRow; | ||
472 | InventoryFolderBase parentFolder = null; | ||
473 | lock (ds) | ||
474 | { | ||
475 | /* Fetch the parent folder from the database to determine the agent ID. | ||
476 | * Then fetch all inventory folders for that agent from the agent ID. | ||
477 | */ | ||
478 | DataTable inventoryFolderTable = ds.Tables["inventoryfolders"]; | ||
479 | string selectExp = "UUID = '" + parentID + "'"; | ||
480 | parentRow = inventoryFolderTable.Select(selectExp); // Assume at most 1 result | ||
481 | if (parentRow.GetLength(0) >= 1) // No result means parent folder does not exist | ||
482 | { | ||
483 | parentFolder = buildFolder(parentRow[0]); | ||
484 | UUID agentID = parentFolder.Owner; | ||
485 | selectExp = "agentID = '" + agentID + "'"; | ||
486 | folderRows = inventoryFolderTable.Select(selectExp); | ||
487 | } | ||
488 | |||
489 | if (folderRows != null && folderRows.GetLength(0) >= 1) // No result means parent folder does not exist | ||
490 | { // or has no children | ||
491 | /* if we're querying the root folder, just return an unordered list of all folders in the user's | ||
492 | * inventory | ||
493 | */ | ||
494 | if (parentFolder.ParentID == UUID.Zero) | ||
495 | { | ||
496 | foreach (DataRow row in folderRows) | ||
497 | { | ||
498 | InventoryFolderBase curFolder = buildFolder(row); | ||
499 | if (curFolder.ID != parentID) // Return all folders except the parent folder of heirarchy | ||
500 | folders.Add(buildFolder(row)); | ||
501 | } | ||
502 | } // If requesting root folder | ||
503 | /* else we are querying a non-root folder. We currently have a list of all of the user's folders, | ||
504 | * we must construct a list of all folders in the heirarchy below parentID. | ||
505 | * Our first step will be to construct a hash table of all folders, indexed by parent ID. | ||
506 | * Once we have constructed the hash table, we will do a breadth-first traversal on the tree using the | ||
507 | * hash table to find child folders. | ||
508 | */ | ||
509 | else | ||
510 | { // Querying a non-root folder | ||
511 | |||
512 | // Build a hash table of all user's inventory folders, indexed by each folder's parent ID | ||
513 | Dictionary<UUID, List<InventoryFolderBase>> hashtable = | ||
514 | new Dictionary<UUID, List<InventoryFolderBase>>(folderRows.GetLength(0)); | ||
515 | |||
516 | foreach (DataRow row in folderRows) | ||
517 | { | ||
518 | InventoryFolderBase curFolder = buildFolder(row); | ||
519 | if (curFolder.ParentID != UUID.Zero) // Discard root of tree - not needed | ||
520 | { | ||
521 | if (hashtable.ContainsKey(curFolder.ParentID)) | ||
522 | { | ||
523 | // Current folder already has a sibling - append to sibling list | ||
524 | hashtable[curFolder.ParentID].Add(curFolder); | ||
525 | } | ||
526 | else | ||
527 | { | ||
528 | List<InventoryFolderBase> siblingList = new List<InventoryFolderBase>(); | ||
529 | siblingList.Add(curFolder); | ||
530 | // Current folder has no known (yet) siblings | ||
531 | hashtable.Add(curFolder.ParentID, siblingList); | ||
532 | } | ||
533 | } | ||
534 | } // For all inventory folders | ||
535 | |||
536 | // Note: Could release the ds lock here - we don't access folderRows or the database anymore. | ||
537 | // This is somewhat of a moot point as the callers of this function usually lock db anyways. | ||
538 | |||
539 | if (hashtable.ContainsKey(parentID)) // if requested folder does have children | ||
540 | folders.AddRange(hashtable[parentID]); | ||
541 | |||
542 | // BreadthFirstSearch build inventory tree **Note: folders.Count is *not* static | ||
543 | for (int i = 0; i < folders.Count; i++) | ||
544 | if (hashtable.ContainsKey(folders[i].ID)) | ||
545 | folders.AddRange(hashtable[folders[i].ID]); | ||
546 | |||
547 | } // if requesting a subfolder heirarchy | ||
548 | } // if folder parentID exists and has children | ||
549 | } // lock ds | ||
550 | return folders; | ||
551 | } | ||
552 | |||
553 | /// <summary> | ||
554 | /// Returns an inventory item by its UUID | ||
555 | /// </summary> | ||
556 | /// <param name="item">The UUID of the item to be returned</param> | ||
557 | /// <returns>A class containing item information</returns> | ||
558 | public InventoryItemBase getInventoryItem(UUID item) | ||
559 | { | ||
560 | lock (ds) | ||
561 | { | ||
562 | DataRow row = ds.Tables["inventoryitems"].Rows.Find(item.ToString()); | ||
563 | if (row != null) | ||
564 | { | ||
565 | return buildItem(row); | ||
566 | } | ||
567 | else | ||
568 | { | ||
569 | return null; | ||
570 | } | ||
571 | } | ||
572 | } | ||
573 | |||
574 | /// <summary> | ||
575 | /// Returns a specified inventory folder by its UUID | ||
576 | /// </summary> | ||
577 | /// <param name="folder">The UUID of the folder to be returned</param> | ||
578 | /// <returns>A class containing folder information</returns> | ||
579 | public InventoryFolderBase getInventoryFolder(UUID folder) | ||
580 | { | ||
581 | // TODO: Deep voodoo here. If you enable this code then | ||
582 | // multi region breaks. No idea why, but I figured it was | ||
583 | // better to leave multi region at this point. It does mean | ||
584 | // that you don't get to see system textures why creating | ||
585 | // clothes and the like. :( | ||
586 | lock (ds) | ||
587 | { | ||
588 | DataRow row = ds.Tables["inventoryfolders"].Rows.Find(folder.ToString()); | ||
589 | if (row != null) | ||
590 | { | ||
591 | return buildFolder(row); | ||
592 | } | ||
593 | else | ||
594 | { | ||
595 | return null; | ||
596 | } | ||
597 | } | ||
598 | } | ||
599 | |||
600 | /// <summary> | ||
601 | /// Creates a new inventory item based on item | ||
602 | /// </summary> | ||
603 | /// <param name="item">The item to be created</param> | ||
604 | public void addInventoryItem(InventoryItemBase item) | ||
605 | { | ||
606 | addItem(item, true); | ||
607 | } | ||
608 | |||
609 | /// <summary> | ||
610 | /// Updates an inventory item with item (updates based on ID) | ||
611 | /// </summary> | ||
612 | /// <param name="item">The updated item</param> | ||
613 | public void updateInventoryItem(InventoryItemBase item) | ||
614 | { | ||
615 | addItem(item, false); | ||
616 | } | ||
617 | |||
618 | /// <summary> | ||
619 | /// Delete an inventory item | ||
620 | /// </summary> | ||
621 | /// <param name="item">The item UUID</param> | ||
622 | public void deleteInventoryItem(UUID itemID) | ||
623 | { | ||
624 | lock (ds) | ||
625 | { | ||
626 | DataTable inventoryItemTable = ds.Tables["inventoryitems"]; | ||
627 | |||
628 | DataRow inventoryRow = inventoryItemTable.Rows.Find(itemID.ToString()); | ||
629 | if (inventoryRow != null) | ||
630 | { | ||
631 | inventoryRow.Delete(); | ||
632 | } | ||
633 | |||
634 | invItemsDa.Update(ds, "inventoryitems"); | ||
635 | } | ||
636 | } | ||
637 | |||
638 | public InventoryItemBase queryInventoryItem(UUID itemID) | ||
639 | { | ||
640 | return getInventoryItem(itemID); | ||
641 | } | ||
642 | |||
643 | public InventoryFolderBase queryInventoryFolder(UUID folderID) | ||
644 | { | ||
645 | return getInventoryFolder(folderID); | ||
646 | } | ||
647 | |||
648 | /// <summary> | ||
649 | /// Delete all items in the specified folder | ||
650 | /// </summary> | ||
651 | /// <param name="folderId">id of the folder, whose item content should be deleted</param> | ||
652 | /// <todo>this is horribly inefficient, but I don't want to ruin the overall structure of this implementation</todo> | ||
653 | private void deleteItemsInFolder(UUID folderId) | ||
654 | { | ||
655 | List<InventoryItemBase> items = getInventoryInFolder(folderId); | ||
656 | |||
657 | foreach (InventoryItemBase i in items) | ||
658 | deleteInventoryItem(i.ID); | ||
659 | } | ||
660 | |||
661 | /// <summary> | ||
662 | /// Adds a new folder specified by folder | ||
663 | /// </summary> | ||
664 | /// <param name="folder">The inventory folder</param> | ||
665 | public void addInventoryFolder(InventoryFolderBase folder) | ||
666 | { | ||
667 | addFolder(folder, true); | ||
668 | } | ||
669 | |||
670 | /// <summary> | ||
671 | /// Updates a folder based on its ID with folder | ||
672 | /// </summary> | ||
673 | /// <param name="folder">The inventory folder</param> | ||
674 | public void updateInventoryFolder(InventoryFolderBase folder) | ||
675 | { | ||
676 | addFolder(folder, false); | ||
677 | } | ||
678 | |||
679 | /// <summary> | ||
680 | /// Moves a folder based on its ID with folder | ||
681 | /// </summary> | ||
682 | /// <param name="folder">The inventory folder</param> | ||
683 | public void moveInventoryFolder(InventoryFolderBase folder) | ||
684 | { | ||
685 | moveFolder(folder); | ||
686 | } | ||
687 | |||
688 | /// <summary> | ||
689 | /// Delete a folder | ||
690 | /// </summary> | ||
691 | /// <remarks> | ||
692 | /// This will clean-up any child folders and child items as well | ||
693 | /// </remarks> | ||
694 | /// <param name="folderID">the folder UUID</param> | ||
695 | public void deleteInventoryFolder(UUID folderID) | ||
696 | { | ||
697 | lock (ds) | ||
698 | { | ||
699 | List<InventoryFolderBase> subFolders = getFolderHierarchy(folderID); | ||
700 | |||
701 | DataTable inventoryFolderTable = ds.Tables["inventoryfolders"]; | ||
702 | DataRow inventoryRow; | ||
703 | |||
704 | //Delete all sub-folders | ||
705 | foreach (InventoryFolderBase f in subFolders) | ||
706 | { | ||
707 | inventoryRow = inventoryFolderTable.Rows.Find(f.ID.ToString()); | ||
708 | if (inventoryRow != null) | ||
709 | { | ||
710 | deleteItemsInFolder(f.ID); | ||
711 | inventoryRow.Delete(); | ||
712 | } | ||
713 | } | ||
714 | |||
715 | //Delete the actual row | ||
716 | inventoryRow = inventoryFolderTable.Rows.Find(folderID.ToString()); | ||
717 | if (inventoryRow != null) | ||
718 | { | ||
719 | deleteItemsInFolder(folderID); | ||
720 | inventoryRow.Delete(); | ||
721 | } | ||
722 | |||
723 | invFoldersDa.Update(ds, "inventoryfolders"); | ||
724 | } | ||
725 | } | ||
726 | |||
727 | /*********************************************************************** | ||
728 | * | ||
729 | * Data Table definitions | ||
730 | * | ||
731 | **********************************************************************/ | ||
732 | |||
733 | protected void CreateDataSetMapping(IDataAdapter da, string tableName) | ||
734 | { | ||
735 | ITableMapping dbMapping = da.TableMappings.Add(tableName, tableName); | ||
736 | foreach (DataColumn col in ds.Tables[tableName].Columns) | ||
737 | { | ||
738 | dbMapping.ColumnMappings.Add(col.ColumnName, col.ColumnName); | ||
739 | } | ||
740 | } | ||
741 | |||
742 | /// <summary> | ||
743 | /// Create the "inventoryitems" table | ||
744 | /// </summary> | ||
745 | private static DataTable createInventoryItemsTable() | ||
746 | { | ||
747 | DataTable inv = new DataTable("inventoryitems"); | ||
748 | |||
749 | createCol(inv, "UUID", typeof (String)); //inventoryID | ||
750 | createCol(inv, "assetID", typeof (String)); | ||
751 | createCol(inv, "assetType", typeof (Int32)); | ||
752 | createCol(inv, "invType", typeof (Int32)); | ||
753 | createCol(inv, "parentFolderID", typeof (String)); | ||
754 | createCol(inv, "avatarID", typeof (String)); | ||
755 | createCol(inv, "creatorsID", typeof (String)); | ||
756 | |||
757 | createCol(inv, "inventoryName", typeof (String)); | ||
758 | createCol(inv, "inventoryDescription", typeof (String)); | ||
759 | // permissions | ||
760 | createCol(inv, "inventoryNextPermissions", typeof (Int32)); | ||
761 | createCol(inv, "inventoryCurrentPermissions", typeof (Int32)); | ||
762 | createCol(inv, "inventoryBasePermissions", typeof (Int32)); | ||
763 | createCol(inv, "inventoryEveryOnePermissions", typeof (Int32)); | ||
764 | createCol(inv, "inventoryGroupPermissions", typeof (Int32)); | ||
765 | |||
766 | // sale info | ||
767 | createCol(inv, "salePrice", typeof(Int32)); | ||
768 | createCol(inv, "saleType", typeof(Byte)); | ||
769 | |||
770 | // creation date | ||
771 | createCol(inv, "creationDate", typeof(Int32)); | ||
772 | |||
773 | // group info | ||
774 | createCol(inv, "groupID", typeof(String)); | ||
775 | createCol(inv, "groupOwned", typeof(Boolean)); | ||
776 | |||
777 | // Flags | ||
778 | createCol(inv, "flags", typeof(UInt32)); | ||
779 | |||
780 | inv.PrimaryKey = new DataColumn[] { inv.Columns["UUID"] }; | ||
781 | return inv; | ||
782 | } | ||
783 | |||
784 | /// <summary> | ||
785 | /// Creates the "inventoryfolders" table | ||
786 | /// </summary> | ||
787 | /// <returns></returns> | ||
788 | private static DataTable createInventoryFoldersTable() | ||
789 | { | ||
790 | DataTable fol = new DataTable("inventoryfolders"); | ||
791 | |||
792 | createCol(fol, "UUID", typeof (String)); //folderID | ||
793 | createCol(fol, "name", typeof (String)); | ||
794 | createCol(fol, "agentID", typeof (String)); | ||
795 | createCol(fol, "parentID", typeof (String)); | ||
796 | createCol(fol, "type", typeof (Int32)); | ||
797 | createCol(fol, "version", typeof (Int32)); | ||
798 | |||
799 | fol.PrimaryKey = new DataColumn[] {fol.Columns["UUID"]}; | ||
800 | return fol; | ||
801 | } | ||
802 | |||
803 | /// <summary> | ||
804 | /// | ||
805 | /// </summary> | ||
806 | /// <param name="da"></param> | ||
807 | /// <param name="conn"></param> | ||
808 | private void setupItemsCommands(SqliteDataAdapter da, SqliteConnection conn) | ||
809 | { | ||
810 | lock (ds) | ||
811 | { | ||
812 | da.InsertCommand = createInsertCommand("inventoryitems", ds.Tables["inventoryitems"]); | ||
813 | da.InsertCommand.Connection = conn; | ||
814 | |||
815 | da.UpdateCommand = createUpdateCommand("inventoryitems", "UUID=:UUID", ds.Tables["inventoryitems"]); | ||
816 | da.UpdateCommand.Connection = conn; | ||
817 | |||
818 | SqliteCommand delete = new SqliteCommand("delete from inventoryitems where UUID = :UUID"); | ||
819 | delete.Parameters.Add(createSqliteParameter("UUID", typeof(String))); | ||
820 | delete.Connection = conn; | ||
821 | da.DeleteCommand = delete; | ||
822 | } | ||
823 | } | ||
824 | |||
825 | /// <summary> | ||
826 | /// | ||
827 | /// </summary> | ||
828 | /// <param name="da"></param> | ||
829 | /// <param name="conn"></param> | ||
830 | private void setupFoldersCommands(SqliteDataAdapter da, SqliteConnection conn) | ||
831 | { | ||
832 | lock (ds) | ||
833 | { | ||
834 | da.InsertCommand = createInsertCommand("inventoryfolders", ds.Tables["inventoryfolders"]); | ||
835 | da.InsertCommand.Connection = conn; | ||
836 | |||
837 | da.UpdateCommand = createUpdateCommand("inventoryfolders", "UUID=:UUID", ds.Tables["inventoryfolders"]); | ||
838 | da.UpdateCommand.Connection = conn; | ||
839 | |||
840 | SqliteCommand delete = new SqliteCommand("delete from inventoryfolders where UUID = :UUID"); | ||
841 | delete.Parameters.Add(createSqliteParameter("UUID", typeof(String))); | ||
842 | delete.Connection = conn; | ||
843 | da.DeleteCommand = delete; | ||
844 | } | ||
845 | } | ||
846 | |||
847 | /// <summary> | ||
848 | /// | ||
849 | /// </summary> | ||
850 | /// <param name="row"></param> | ||
851 | /// <returns></returns> | ||
852 | private static InventoryFolderBase buildFolder(DataRow row) | ||
853 | { | ||
854 | InventoryFolderBase folder = new InventoryFolderBase(); | ||
855 | folder.ID = new UUID((string) row["UUID"]); | ||
856 | folder.Name = (string) row["name"]; | ||
857 | folder.Owner = new UUID((string) row["agentID"]); | ||
858 | folder.ParentID = new UUID((string) row["parentID"]); | ||
859 | folder.Type = Convert.ToInt16(row["type"]); | ||
860 | folder.Version = Convert.ToUInt16(row["version"]); | ||
861 | return folder; | ||
862 | } | ||
863 | |||
864 | /// <summary> | ||
865 | /// | ||
866 | /// </summary> | ||
867 | /// <param name="row"></param> | ||
868 | /// <param name="folder"></param> | ||
869 | private static void fillFolderRow(DataRow row, InventoryFolderBase folder) | ||
870 | { | ||
871 | row["UUID"] = folder.ID.ToString(); | ||
872 | row["name"] = folder.Name; | ||
873 | row["agentID"] = folder.Owner.ToString(); | ||
874 | row["parentID"] = folder.ParentID.ToString(); | ||
875 | row["type"] = folder.Type; | ||
876 | row["version"] = folder.Version; | ||
877 | } | ||
878 | |||
879 | /// <summary> | ||
880 | /// | ||
881 | /// </summary> | ||
882 | /// <param name="row"></param> | ||
883 | /// <param name="folder"></param> | ||
884 | private static void moveFolderRow(DataRow row, InventoryFolderBase folder) | ||
885 | { | ||
886 | row["UUID"] = folder.ID.ToString(); | ||
887 | row["parentID"] = folder.ParentID.ToString(); | ||
888 | } | ||
889 | |||
890 | public List<InventoryItemBase> fetchActiveGestures (UUID avatarID) | ||
891 | { | ||
892 | lock (ds) | ||
893 | { | ||
894 | List<InventoryItemBase> items = new List<InventoryItemBase>(); | ||
895 | |||
896 | DataTable inventoryItemTable = ds.Tables["inventoryitems"]; | ||
897 | string selectExp | ||
898 | = "avatarID = '" + avatarID + "' AND assetType = " + (int)AssetType.Gesture + " AND flags = 1"; | ||
899 | //m_log.DebugFormat("[SQL]: sql = " + selectExp); | ||
900 | DataRow[] rows = inventoryItemTable.Select(selectExp); | ||
901 | foreach (DataRow row in rows) | ||
902 | { | ||
903 | items.Add(buildItem(row)); | ||
904 | } | ||
905 | return items; | ||
906 | } | ||
907 | } | ||
908 | } | ||
909 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteRegionData.cs b/OpenSim/Data/SQLiteNG/SQLiteRegionData.cs new file mode 100644 index 0000000..bad8adc --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteRegionData.cs | |||
@@ -0,0 +1,2318 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections.Generic; | ||
30 | using System.Data; | ||
31 | using System.Drawing; | ||
32 | using System.IO; | ||
33 | using System.Reflection; | ||
34 | using log4net; | ||
35 | using Mono.Data.Sqlite; | ||
36 | using OpenMetaverse; | ||
37 | using OpenSim.Framework; | ||
38 | using OpenSim.Region.Framework.Interfaces; | ||
39 | using OpenSim.Region.Framework.Scenes; | ||
40 | |||
41 | namespace OpenSim.Data.SQLite | ||
42 | { | ||
43 | /// <summary> | ||
44 | /// A RegionData Interface to the SQLite database | ||
45 | /// </summary> | ||
46 | public class SQLiteRegionData : IRegionDataStore | ||
47 | { | ||
48 | private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
49 | |||
50 | private const string primSelect = "select * from prims"; | ||
51 | private const string shapeSelect = "select * from primshapes"; | ||
52 | private const string itemsSelect = "select * from primitems"; | ||
53 | private const string terrainSelect = "select * from terrain limit 1"; | ||
54 | private const string landSelect = "select * from land"; | ||
55 | private const string landAccessListSelect = "select distinct * from landaccesslist"; | ||
56 | private const string regionbanListSelect = "select * from regionban"; | ||
57 | private const string regionSettingsSelect = "select * from regionsettings"; | ||
58 | |||
59 | private DataSet ds; | ||
60 | private SqliteDataAdapter primDa; | ||
61 | private SqliteDataAdapter shapeDa; | ||
62 | private SqliteDataAdapter itemsDa; | ||
63 | private SqliteDataAdapter terrainDa; | ||
64 | private SqliteDataAdapter landDa; | ||
65 | private SqliteDataAdapter landAccessListDa; | ||
66 | private SqliteDataAdapter regionSettingsDa; | ||
67 | |||
68 | private SqliteConnection m_conn; | ||
69 | |||
70 | private String m_connectionString; | ||
71 | |||
72 | // Temporary attribute while this is experimental | ||
73 | |||
74 | /*********************************************************************** | ||
75 | * | ||
76 | * Public Interface Functions | ||
77 | * | ||
78 | **********************************************************************/ | ||
79 | |||
80 | /// <summary> | ||
81 | /// See IRegionDataStore | ||
82 | /// <list type="bullet"> | ||
83 | /// <item>Initialises RegionData Interface</item> | ||
84 | /// <item>Loads and initialises a new SQLite connection and maintains it.</item> | ||
85 | /// </list> | ||
86 | /// </summary> | ||
87 | /// <param name="connectionString">the connection string</param> | ||
88 | public void Initialise(string connectionString) | ||
89 | { | ||
90 | try | ||
91 | { | ||
92 | m_connectionString = connectionString; | ||
93 | |||
94 | ds = new DataSet("Region"); | ||
95 | |||
96 | m_log.Info("[REGION DB]: Sqlite - connecting: " + connectionString); | ||
97 | m_conn = new SqliteConnection(m_connectionString); | ||
98 | m_conn.Open(); | ||
99 | |||
100 | SqliteCommand primSelectCmd = new SqliteCommand(primSelect, m_conn); | ||
101 | //SqliteCommand primSelectCmd = new SqliteCommand(primSelect, m_conn); | ||
102 | //primDa = new SqliteDataAdapter(primSelectCmd); | ||
103 | primDa = new SqliteDataAdapter(primSelect, m_connectionString); | ||
104 | // SqliteCommandBuilder primCb = new SqliteCommandBuilder(primDa); | ||
105 | |||
106 | SqliteCommand shapeSelectCmd = new SqliteCommand(shapeSelect, m_conn); | ||
107 | shapeDa = new SqliteDataAdapter(shapeSelectCmd); | ||
108 | // SqliteCommandBuilder shapeCb = new SqliteCommandBuilder(shapeDa); | ||
109 | |||
110 | SqliteCommand itemsSelectCmd = new SqliteCommand(itemsSelect, m_conn); | ||
111 | itemsDa = new SqliteDataAdapter(itemsSelectCmd); | ||
112 | |||
113 | SqliteCommand terrainSelectCmd = new SqliteCommand(terrainSelect, m_conn); | ||
114 | terrainDa = new SqliteDataAdapter(terrainSelectCmd); | ||
115 | |||
116 | SqliteCommand landSelectCmd = new SqliteCommand(landSelect, m_conn); | ||
117 | landDa = new SqliteDataAdapter(landSelectCmd); | ||
118 | |||
119 | SqliteCommand landAccessListSelectCmd = new SqliteCommand(landAccessListSelect, m_conn); | ||
120 | landAccessListDa = new SqliteDataAdapter(landAccessListSelectCmd); | ||
121 | |||
122 | SqliteCommand regionSettingsSelectCmd = new SqliteCommand(regionSettingsSelect, m_conn); | ||
123 | regionSettingsDa = new SqliteDataAdapter(regionSettingsSelectCmd); | ||
124 | // This actually does the roll forward assembly stuff | ||
125 | Assembly assem = GetType().Assembly; | ||
126 | Migration m = new Migration(m_conn, assem, "RegionStore"); | ||
127 | m.Update(); | ||
128 | |||
129 | lock (ds) | ||
130 | { | ||
131 | //ds.Tables.Add(createPrimTable()); | ||
132 | //setupPrimCommands(primDa, m_conn); | ||
133 | //primDa.Fill(ds.Tables["prims"]); | ||
134 | primDa.Fill(ds, "prims"); | ||
135 | |||
136 | ds.Tables.Add(createShapeTable()); | ||
137 | setupShapeCommands(shapeDa, m_conn); | ||
138 | |||
139 | ds.Tables.Add(createItemsTable()); | ||
140 | setupItemsCommands(itemsDa, m_conn); | ||
141 | itemsDa.Fill(ds.Tables["primitems"]); | ||
142 | |||
143 | ds.Tables.Add(createTerrainTable()); | ||
144 | setupTerrainCommands(terrainDa, m_conn); | ||
145 | |||
146 | ds.Tables.Add(createLandTable()); | ||
147 | setupLandCommands(landDa, m_conn); | ||
148 | |||
149 | ds.Tables.Add(createLandAccessListTable()); | ||
150 | setupLandAccessCommands(landAccessListDa, m_conn); | ||
151 | |||
152 | ds.Tables.Add(createRegionSettingsTable()); | ||
153 | |||
154 | setupRegionSettingsCommands(regionSettingsDa, m_conn); | ||
155 | |||
156 | // WORKAROUND: This is a work around for sqlite on | ||
157 | // windows, which gets really unhappy with blob columns | ||
158 | // that have no sample data in them. At some point we | ||
159 | // need to actually find a proper way to handle this. | ||
160 | try | ||
161 | { | ||
162 | shapeDa.Fill(ds.Tables["primshapes"]); | ||
163 | } | ||
164 | catch (Exception) | ||
165 | { | ||
166 | m_log.Info("[REGION DB]: Caught fill error on primshapes table"); | ||
167 | } | ||
168 | |||
169 | try | ||
170 | { | ||
171 | terrainDa.Fill(ds.Tables["terrain"]); | ||
172 | } | ||
173 | catch (Exception) | ||
174 | { | ||
175 | m_log.Info("[REGION DB]: Caught fill error on terrain table"); | ||
176 | } | ||
177 | |||
178 | try | ||
179 | { | ||
180 | landDa.Fill(ds.Tables["land"]); | ||
181 | } | ||
182 | catch (Exception) | ||
183 | { | ||
184 | m_log.Info("[REGION DB]: Caught fill error on land table"); | ||
185 | } | ||
186 | |||
187 | try | ||
188 | { | ||
189 | landAccessListDa.Fill(ds.Tables["landaccesslist"]); | ||
190 | } | ||
191 | catch (Exception) | ||
192 | { | ||
193 | m_log.Info("[REGION DB]: Caught fill error on landaccesslist table"); | ||
194 | } | ||
195 | |||
196 | try | ||
197 | { | ||
198 | regionSettingsDa.Fill(ds.Tables["regionsettings"]); | ||
199 | } | ||
200 | catch (Exception) | ||
201 | { | ||
202 | m_log.Info("[REGION DB]: Caught fill error on regionsettings table"); | ||
203 | } | ||
204 | |||
205 | // We have to create a data set mapping for every table, otherwise the IDataAdaptor.Update() will not populate rows with values! | ||
206 | // Not sure exactly why this is - this kind of thing was not necessary before - justincc 20100409 | ||
207 | CreateDataSetMapping(primDa, "prims"); | ||
208 | CreateDataSetMapping(shapeDa, "primshapes"); | ||
209 | CreateDataSetMapping(itemsDa, "primitems"); | ||
210 | CreateDataSetMapping(terrainDa, "terrain"); | ||
211 | CreateDataSetMapping(landDa, "land"); | ||
212 | CreateDataSetMapping(landAccessListDa, "landaccesslist"); | ||
213 | CreateDataSetMapping(regionSettingsDa, "regionsettings"); | ||
214 | } | ||
215 | } | ||
216 | catch (Exception e) | ||
217 | { | ||
218 | m_log.Error(e); | ||
219 | Environment.Exit(23); | ||
220 | } | ||
221 | |||
222 | return; | ||
223 | } | ||
224 | |||
225 | public void Dispose() | ||
226 | { | ||
227 | if (m_conn != null) | ||
228 | { | ||
229 | m_conn.Close(); | ||
230 | m_conn = null; | ||
231 | } | ||
232 | if (ds != null) | ||
233 | { | ||
234 | ds.Dispose(); | ||
235 | ds = null; | ||
236 | } | ||
237 | if (primDa != null) | ||
238 | { | ||
239 | primDa.Dispose(); | ||
240 | primDa = null; | ||
241 | } | ||
242 | if (shapeDa != null) | ||
243 | { | ||
244 | shapeDa.Dispose(); | ||
245 | shapeDa = null; | ||
246 | } | ||
247 | if (itemsDa != null) | ||
248 | { | ||
249 | itemsDa.Dispose(); | ||
250 | itemsDa = null; | ||
251 | } | ||
252 | if (terrainDa != null) | ||
253 | { | ||
254 | terrainDa.Dispose(); | ||
255 | terrainDa = null; | ||
256 | } | ||
257 | if (landDa != null) | ||
258 | { | ||
259 | landDa.Dispose(); | ||
260 | landDa = null; | ||
261 | } | ||
262 | if (landAccessListDa != null) | ||
263 | { | ||
264 | landAccessListDa.Dispose(); | ||
265 | landAccessListDa = null; | ||
266 | } | ||
267 | if (regionSettingsDa != null) | ||
268 | { | ||
269 | regionSettingsDa.Dispose(); | ||
270 | regionSettingsDa = null; | ||
271 | } | ||
272 | } | ||
273 | |||
274 | public void StoreRegionSettings(RegionSettings rs) | ||
275 | { | ||
276 | lock (ds) | ||
277 | { | ||
278 | DataTable regionsettings = ds.Tables["regionsettings"]; | ||
279 | |||
280 | DataRow settingsRow = regionsettings.Rows.Find(rs.RegionUUID.ToString()); | ||
281 | if (settingsRow == null) | ||
282 | { | ||
283 | settingsRow = regionsettings.NewRow(); | ||
284 | fillRegionSettingsRow(settingsRow, rs); | ||
285 | regionsettings.Rows.Add(settingsRow); | ||
286 | } | ||
287 | else | ||
288 | { | ||
289 | fillRegionSettingsRow(settingsRow, rs); | ||
290 | } | ||
291 | |||
292 | Commit(); | ||
293 | } | ||
294 | } | ||
295 | public RegionLightShareData LoadRegionWindlightSettings(UUID regionUUID) | ||
296 | { | ||
297 | //This connector doesn't support the windlight module yet | ||
298 | //Return default LL windlight settings | ||
299 | return new RegionLightShareData(); | ||
300 | } | ||
301 | public void StoreRegionWindlightSettings(RegionLightShareData wl) | ||
302 | { | ||
303 | //This connector doesn't support the windlight module yet | ||
304 | } | ||
305 | public RegionSettings LoadRegionSettings(UUID regionUUID) | ||
306 | { | ||
307 | lock (ds) | ||
308 | { | ||
309 | DataTable regionsettings = ds.Tables["regionsettings"]; | ||
310 | |||
311 | string searchExp = "regionUUID = '" + regionUUID.ToString() + "'"; | ||
312 | DataRow[] rawsettings = regionsettings.Select(searchExp); | ||
313 | if (rawsettings.Length == 0) | ||
314 | { | ||
315 | RegionSettings rs = new RegionSettings(); | ||
316 | rs.RegionUUID = regionUUID; | ||
317 | rs.OnSave += StoreRegionSettings; | ||
318 | |||
319 | StoreRegionSettings(rs); | ||
320 | |||
321 | return rs; | ||
322 | } | ||
323 | DataRow row = rawsettings[0]; | ||
324 | |||
325 | RegionSettings newSettings = buildRegionSettings(row); | ||
326 | newSettings.OnSave += StoreRegionSettings; | ||
327 | |||
328 | return newSettings; | ||
329 | } | ||
330 | } | ||
331 | |||
332 | /// <summary> | ||
333 | /// Adds an object into region storage | ||
334 | /// </summary> | ||
335 | /// <param name="obj">the object</param> | ||
336 | /// <param name="regionUUID">the region UUID</param> | ||
337 | public void StoreObject(SceneObjectGroup obj, UUID regionUUID) | ||
338 | { | ||
339 | uint flags = obj.RootPart.GetEffectiveObjectFlags(); | ||
340 | |||
341 | // Eligibility check | ||
342 | // | ||
343 | if ((flags & (uint)PrimFlags.Temporary) != 0) | ||
344 | return; | ||
345 | if ((flags & (uint)PrimFlags.TemporaryOnRez) != 0) | ||
346 | return; | ||
347 | |||
348 | lock (ds) | ||
349 | { | ||
350 | foreach (SceneObjectPart prim in obj.Children.Values) | ||
351 | { | ||
352 | // m_log.Info("[REGION DB]: Adding obj: " + obj.UUID + " to region: " + regionUUID); | ||
353 | addPrim(prim, obj.UUID, regionUUID); | ||
354 | } | ||
355 | } | ||
356 | |||
357 | Commit(); | ||
358 | // m_log.Info("[Dump of prims]: " + ds.GetXml()); | ||
359 | } | ||
360 | |||
361 | /// <summary> | ||
362 | /// Removes an object from region storage | ||
363 | /// </summary> | ||
364 | /// <param name="obj">the object</param> | ||
365 | /// <param name="regionUUID">the region UUID</param> | ||
366 | public void RemoveObject(UUID obj, UUID regionUUID) | ||
367 | { | ||
368 | // m_log.InfoFormat("[REGION DB]: Removing obj: {0} from region: {1}", obj.Guid, regionUUID); | ||
369 | |||
370 | DataTable prims = ds.Tables["prims"]; | ||
371 | DataTable shapes = ds.Tables["primshapes"]; | ||
372 | |||
373 | string selectExp = "SceneGroupID = '" + obj + "' and RegionUUID = '" + regionUUID + "'"; | ||
374 | lock (ds) | ||
375 | { | ||
376 | DataRow[] primRows = prims.Select(selectExp); | ||
377 | foreach (DataRow row in primRows) | ||
378 | { | ||
379 | // Remove shape rows | ||
380 | UUID uuid = new UUID((string) row["UUID"]); | ||
381 | DataRow shapeRow = shapes.Rows.Find(uuid.ToString()); | ||
382 | if (shapeRow != null) | ||
383 | { | ||
384 | shapeRow.Delete(); | ||
385 | } | ||
386 | |||
387 | RemoveItems(uuid); | ||
388 | |||
389 | // Remove prim row | ||
390 | row.Delete(); | ||
391 | } | ||
392 | } | ||
393 | |||
394 | Commit(); | ||
395 | } | ||
396 | |||
397 | /// <summary> | ||
398 | /// Remove all persisted items of the given prim. | ||
399 | /// The caller must acquire the necessrary synchronization locks and commit or rollback changes. | ||
400 | /// </summary> | ||
401 | /// <param name="uuid">The item UUID</param> | ||
402 | private void RemoveItems(UUID uuid) | ||
403 | { | ||
404 | DataTable items = ds.Tables["primitems"]; | ||
405 | |||
406 | String sql = String.Format("primID = '{0}'", uuid); | ||
407 | DataRow[] itemRows = items.Select(sql); | ||
408 | |||
409 | foreach (DataRow itemRow in itemRows) | ||
410 | { | ||
411 | itemRow.Delete(); | ||
412 | } | ||
413 | } | ||
414 | |||
415 | /// <summary> | ||
416 | /// Load persisted objects from region storage. | ||
417 | /// </summary> | ||
418 | /// <param name="regionUUID">The region UUID</param> | ||
419 | /// <returns>List of loaded groups</returns> | ||
420 | public List<SceneObjectGroup> LoadObjects(UUID regionUUID) | ||
421 | { | ||
422 | Dictionary<UUID, SceneObjectGroup> createdObjects = new Dictionary<UUID, SceneObjectGroup>(); | ||
423 | |||
424 | List<SceneObjectGroup> retvals = new List<SceneObjectGroup>(); | ||
425 | |||
426 | DataTable prims = ds.Tables["prims"]; | ||
427 | DataTable shapes = ds.Tables["primshapes"]; | ||
428 | |||
429 | string byRegion = "RegionUUID = '" + regionUUID + "'"; | ||
430 | |||
431 | lock (ds) | ||
432 | { | ||
433 | DataRow[] primsForRegion = prims.Select(byRegion); | ||
434 | m_log.Info("[REGION DB]: Loaded " + primsForRegion.Length + " prims for region: " + regionUUID); | ||
435 | |||
436 | // First, create all groups | ||
437 | foreach (DataRow primRow in primsForRegion) | ||
438 | { | ||
439 | try | ||
440 | { | ||
441 | SceneObjectPart prim = null; | ||
442 | |||
443 | string uuid = (string) primRow["UUID"]; | ||
444 | string objID = (string) primRow["SceneGroupID"]; | ||
445 | |||
446 | if (uuid == objID) //is new SceneObjectGroup ? | ||
447 | { | ||
448 | prim = buildPrim(primRow); | ||
449 | DataRow shapeRow = shapes.Rows.Find(prim.UUID.ToString()); | ||
450 | if (shapeRow != null) | ||
451 | { | ||
452 | prim.Shape = buildShape(shapeRow); | ||
453 | } | ||
454 | else | ||
455 | { | ||
456 | m_log.Info( | ||
457 | "[REGION DB]: No shape found for prim in storage, so setting default box shape"); | ||
458 | prim.Shape = PrimitiveBaseShape.Default; | ||
459 | } | ||
460 | |||
461 | SceneObjectGroup group = new SceneObjectGroup(prim); | ||
462 | createdObjects.Add(group.UUID, group); | ||
463 | retvals.Add(group); | ||
464 | LoadItems(prim); | ||
465 | } | ||
466 | } | ||
467 | catch (Exception e) | ||
468 | { | ||
469 | m_log.Error("[REGION DB]: Failed create prim object in new group, exception and data follows"); | ||
470 | m_log.Info("[REGION DB]: " + e.ToString()); | ||
471 | foreach (DataColumn col in prims.Columns) | ||
472 | { | ||
473 | m_log.Info("[REGION DB]: Col: " + col.ColumnName + " => " + primRow[col]); | ||
474 | } | ||
475 | } | ||
476 | } | ||
477 | |||
478 | // Now fill the groups with part data | ||
479 | foreach (DataRow primRow in primsForRegion) | ||
480 | { | ||
481 | try | ||
482 | { | ||
483 | SceneObjectPart prim = null; | ||
484 | |||
485 | string uuid = (string) primRow["UUID"]; | ||
486 | string objID = (string) primRow["SceneGroupID"]; | ||
487 | if (uuid != objID) //is new SceneObjectGroup ? | ||
488 | { | ||
489 | prim = buildPrim(primRow); | ||
490 | DataRow shapeRow = shapes.Rows.Find(prim.UUID.ToString()); | ||
491 | if (shapeRow != null) | ||
492 | { | ||
493 | prim.Shape = buildShape(shapeRow); | ||
494 | } | ||
495 | else | ||
496 | { | ||
497 | m_log.Warn( | ||
498 | "[REGION DB]: No shape found for prim in storage, so setting default box shape"); | ||
499 | prim.Shape = PrimitiveBaseShape.Default; | ||
500 | } | ||
501 | |||
502 | createdObjects[new UUID(objID)].AddPart(prim); | ||
503 | LoadItems(prim); | ||
504 | } | ||
505 | } | ||
506 | catch (Exception e) | ||
507 | { | ||
508 | m_log.Error("[REGION DB]: Failed create prim object in group, exception and data follows"); | ||
509 | m_log.Info("[REGION DB]: " + e.ToString()); | ||
510 | foreach (DataColumn col in prims.Columns) | ||
511 | { | ||
512 | m_log.Info("[REGION DB]: Col: " + col.ColumnName + " => " + primRow[col]); | ||
513 | } | ||
514 | } | ||
515 | } | ||
516 | } | ||
517 | return retvals; | ||
518 | } | ||
519 | |||
520 | /// <summary> | ||
521 | /// Load in a prim's persisted inventory. | ||
522 | /// </summary> | ||
523 | /// <param name="prim">the prim</param> | ||
524 | private void LoadItems(SceneObjectPart prim) | ||
525 | { | ||
526 | //m_log.DebugFormat("[DATASTORE]: Loading inventory for {0}, {1}", prim.Name, prim.UUID); | ||
527 | |||
528 | DataTable dbItems = ds.Tables["primitems"]; | ||
529 | String sql = String.Format("primID = '{0}'", prim.UUID.ToString()); | ||
530 | DataRow[] dbItemRows = dbItems.Select(sql); | ||
531 | IList<TaskInventoryItem> inventory = new List<TaskInventoryItem>(); | ||
532 | |||
533 | foreach (DataRow row in dbItemRows) | ||
534 | { | ||
535 | TaskInventoryItem item = buildItem(row); | ||
536 | inventory.Add(item); | ||
537 | |||
538 | //m_log.DebugFormat("[DATASTORE]: Restored item {0}, {1}", item.Name, item.ItemID); | ||
539 | } | ||
540 | |||
541 | prim.Inventory.RestoreInventoryItems(inventory); | ||
542 | } | ||
543 | |||
544 | /// <summary> | ||
545 | /// Store a terrain revision in region storage | ||
546 | /// </summary> | ||
547 | /// <param name="ter">terrain heightfield</param> | ||
548 | /// <param name="regionID">region UUID</param> | ||
549 | public void StoreTerrain(double[,] ter, UUID regionID) | ||
550 | { | ||
551 | lock (ds) | ||
552 | { | ||
553 | int revision = Util.UnixTimeSinceEpoch(); | ||
554 | |||
555 | // This is added to get rid of the infinitely growing | ||
556 | // terrain databases which negatively impact on SQLite | ||
557 | // over time. Before reenabling this feature there | ||
558 | // needs to be a limitter put on the number of | ||
559 | // revisions in the database, as this old | ||
560 | // implementation is a DOS attack waiting to happen. | ||
561 | |||
562 | using ( | ||
563 | SqliteCommand cmd = | ||
564 | new SqliteCommand("delete from terrain where RegionUUID=:RegionUUID and Revision <= :Revision", | ||
565 | m_conn)) | ||
566 | { | ||
567 | cmd.Parameters.Add(new SqliteParameter(":RegionUUID", regionID.ToString())); | ||
568 | cmd.Parameters.Add(new SqliteParameter(":Revision", revision)); | ||
569 | cmd.ExecuteNonQuery(); | ||
570 | } | ||
571 | |||
572 | // the following is an work around for .NET. The perf | ||
573 | // issues associated with it aren't as bad as you think. | ||
574 | m_log.Info("[REGION DB]: Storing terrain revision r" + revision.ToString()); | ||
575 | String sql = "insert into terrain(RegionUUID, Revision, Heightfield)" + | ||
576 | " values(:RegionUUID, :Revision, :Heightfield)"; | ||
577 | |||
578 | using (SqliteCommand cmd = new SqliteCommand(sql, m_conn)) | ||
579 | { | ||
580 | cmd.Parameters.Add(new SqliteParameter(":RegionUUID", regionID.ToString())); | ||
581 | cmd.Parameters.Add(new SqliteParameter(":Revision", revision)); | ||
582 | cmd.Parameters.Add(new SqliteParameter(":Heightfield", serializeTerrain(ter))); | ||
583 | cmd.ExecuteNonQuery(); | ||
584 | } | ||
585 | } | ||
586 | } | ||
587 | |||
588 | /// <summary> | ||
589 | /// Load the latest terrain revision from region storage | ||
590 | /// </summary> | ||
591 | /// <param name="regionID">the region UUID</param> | ||
592 | /// <returns>Heightfield data</returns> | ||
593 | public double[,] LoadTerrain(UUID regionID) | ||
594 | { | ||
595 | lock (ds) | ||
596 | { | ||
597 | double[,] terret = new double[(int)Constants.RegionSize, (int)Constants.RegionSize]; | ||
598 | terret.Initialize(); | ||
599 | |||
600 | String sql = "select RegionUUID, Revision, Heightfield from terrain" + | ||
601 | " where RegionUUID=:RegionUUID order by Revision desc"; | ||
602 | |||
603 | using (SqliteCommand cmd = new SqliteCommand(sql, m_conn)) | ||
604 | { | ||
605 | cmd.Parameters.Add(new SqliteParameter(":RegionUUID", regionID.ToString())); | ||
606 | |||
607 | using (IDataReader row = cmd.ExecuteReader()) | ||
608 | { | ||
609 | int rev = 0; | ||
610 | if (row.Read()) | ||
611 | { | ||
612 | // TODO: put this into a function | ||
613 | using (MemoryStream str = new MemoryStream((byte[])row["Heightfield"])) | ||
614 | { | ||
615 | using (BinaryReader br = new BinaryReader(str)) | ||
616 | { | ||
617 | for (int x = 0; x < (int)Constants.RegionSize; x++) | ||
618 | { | ||
619 | for (int y = 0; y < (int)Constants.RegionSize; y++) | ||
620 | { | ||
621 | terret[x, y] = br.ReadDouble(); | ||
622 | } | ||
623 | } | ||
624 | } | ||
625 | } | ||
626 | rev = Convert.ToInt32(row["Revision"]); | ||
627 | } | ||
628 | else | ||
629 | { | ||
630 | m_log.Info("[REGION DB]: No terrain found for region"); | ||
631 | return null; | ||
632 | } | ||
633 | |||
634 | m_log.Info("[REGION DB]: Loaded terrain revision r" + rev.ToString()); | ||
635 | } | ||
636 | } | ||
637 | return terret; | ||
638 | } | ||
639 | } | ||
640 | |||
641 | /// <summary> | ||
642 | /// | ||
643 | /// </summary> | ||
644 | /// <param name="globalID"></param> | ||
645 | public void RemoveLandObject(UUID globalID) | ||
646 | { | ||
647 | lock (ds) | ||
648 | { | ||
649 | // Can't use blanket SQL statements when using SqlAdapters unless you re-read the data into the adapter | ||
650 | // after you're done. | ||
651 | // replaced below code with the SqliteAdapter version. | ||
652 | //using (SqliteCommand cmd = new SqliteCommand("delete from land where UUID=:UUID", m_conn)) | ||
653 | //{ | ||
654 | // cmd.Parameters.Add(new SqliteParameter(":UUID", globalID.ToString())); | ||
655 | // cmd.ExecuteNonQuery(); | ||
656 | //} | ||
657 | |||
658 | //using (SqliteCommand cmd = new SqliteCommand("delete from landaccesslist where LandUUID=:UUID", m_conn)) | ||
659 | //{ | ||
660 | // cmd.Parameters.Add(new SqliteParameter(":UUID", globalID.ToString())); | ||
661 | // cmd.ExecuteNonQuery(); | ||
662 | //} | ||
663 | |||
664 | DataTable land = ds.Tables["land"]; | ||
665 | DataTable landaccesslist = ds.Tables["landaccesslist"]; | ||
666 | DataRow landRow = land.Rows.Find(globalID.ToString()); | ||
667 | if (landRow != null) | ||
668 | { | ||
669 | land.Rows.Remove(landRow); | ||
670 | } | ||
671 | List<DataRow> rowsToDelete = new List<DataRow>(); | ||
672 | foreach (DataRow rowToCheck in landaccesslist.Rows) | ||
673 | { | ||
674 | if (rowToCheck["LandUUID"].ToString() == globalID.ToString()) | ||
675 | rowsToDelete.Add(rowToCheck); | ||
676 | } | ||
677 | for (int iter = 0; iter < rowsToDelete.Count; iter++) | ||
678 | { | ||
679 | landaccesslist.Rows.Remove(rowsToDelete[iter]); | ||
680 | } | ||
681 | |||
682 | |||
683 | } | ||
684 | Commit(); | ||
685 | } | ||
686 | |||
687 | /// <summary> | ||
688 | /// | ||
689 | /// </summary> | ||
690 | /// <param name="parcel"></param> | ||
691 | public void StoreLandObject(ILandObject parcel) | ||
692 | { | ||
693 | lock (ds) | ||
694 | { | ||
695 | DataTable land = ds.Tables["land"]; | ||
696 | DataTable landaccesslist = ds.Tables["landaccesslist"]; | ||
697 | |||
698 | DataRow landRow = land.Rows.Find(parcel.LandData.GlobalID.ToString()); | ||
699 | if (landRow == null) | ||
700 | { | ||
701 | landRow = land.NewRow(); | ||
702 | fillLandRow(landRow, parcel.LandData, parcel.RegionUUID); | ||
703 | land.Rows.Add(landRow); | ||
704 | } | ||
705 | else | ||
706 | { | ||
707 | fillLandRow(landRow, parcel.LandData, parcel.RegionUUID); | ||
708 | } | ||
709 | |||
710 | // I know this caused someone issues before, but OpenSim is unusable if we leave this stuff around | ||
711 | //using (SqliteCommand cmd = new SqliteCommand("delete from landaccesslist where LandUUID=:LandUUID", m_conn)) | ||
712 | //{ | ||
713 | // cmd.Parameters.Add(new SqliteParameter(":LandUUID", parcel.LandData.GlobalID.ToString())); | ||
714 | // cmd.ExecuteNonQuery(); | ||
715 | |||
716 | // } | ||
717 | |||
718 | // This is the slower.. but more appropriate thing to do | ||
719 | |||
720 | // We can't modify the table with direct queries before calling Commit() and re-filling them. | ||
721 | List<DataRow> rowsToDelete = new List<DataRow>(); | ||
722 | foreach (DataRow rowToCheck in landaccesslist.Rows) | ||
723 | { | ||
724 | if (rowToCheck["LandUUID"].ToString() == parcel.LandData.GlobalID.ToString()) | ||
725 | rowsToDelete.Add(rowToCheck); | ||
726 | } | ||
727 | for (int iter = 0; iter < rowsToDelete.Count; iter++) | ||
728 | { | ||
729 | landaccesslist.Rows.Remove(rowsToDelete[iter]); | ||
730 | } | ||
731 | rowsToDelete.Clear(); | ||
732 | foreach (ParcelManager.ParcelAccessEntry entry in parcel.LandData.ParcelAccessList) | ||
733 | { | ||
734 | DataRow newAccessRow = landaccesslist.NewRow(); | ||
735 | fillLandAccessRow(newAccessRow, entry, parcel.LandData.GlobalID); | ||
736 | landaccesslist.Rows.Add(newAccessRow); | ||
737 | } | ||
738 | } | ||
739 | |||
740 | Commit(); | ||
741 | } | ||
742 | |||
743 | /// <summary> | ||
744 | /// | ||
745 | /// </summary> | ||
746 | /// <param name="regionUUID"></param> | ||
747 | /// <returns></returns> | ||
748 | public List<LandData> LoadLandObjects(UUID regionUUID) | ||
749 | { | ||
750 | List<LandData> landDataForRegion = new List<LandData>(); | ||
751 | lock (ds) | ||
752 | { | ||
753 | DataTable land = ds.Tables["land"]; | ||
754 | DataTable landaccesslist = ds.Tables["landaccesslist"]; | ||
755 | string searchExp = "RegionUUID = '" + regionUUID + "'"; | ||
756 | DataRow[] rawDataForRegion = land.Select(searchExp); | ||
757 | foreach (DataRow rawDataLand in rawDataForRegion) | ||
758 | { | ||
759 | LandData newLand = buildLandData(rawDataLand); | ||
760 | string accessListSearchExp = "LandUUID = '" + newLand.GlobalID + "'"; | ||
761 | DataRow[] rawDataForLandAccessList = landaccesslist.Select(accessListSearchExp); | ||
762 | foreach (DataRow rawDataLandAccess in rawDataForLandAccessList) | ||
763 | { | ||
764 | newLand.ParcelAccessList.Add(buildLandAccessData(rawDataLandAccess)); | ||
765 | } | ||
766 | |||
767 | landDataForRegion.Add(newLand); | ||
768 | } | ||
769 | } | ||
770 | return landDataForRegion; | ||
771 | } | ||
772 | |||
773 | /// <summary> | ||
774 | /// | ||
775 | /// </summary> | ||
776 | public void Commit() | ||
777 | { | ||
778 | m_log.Debug("[SQLITE]: Starting commit"); | ||
779 | lock (ds) | ||
780 | { | ||
781 | primDa.Update(ds, "prims"); | ||
782 | shapeDa.Update(ds, "primshapes"); | ||
783 | |||
784 | itemsDa.Update(ds, "primitems"); | ||
785 | |||
786 | terrainDa.Update(ds, "terrain"); | ||
787 | landDa.Update(ds, "land"); | ||
788 | landAccessListDa.Update(ds, "landaccesslist"); | ||
789 | try | ||
790 | { | ||
791 | regionSettingsDa.Update(ds, "regionsettings"); | ||
792 | } | ||
793 | catch (SqliteException SqlEx) | ||
794 | { | ||
795 | throw new Exception( | ||
796 | "There was a SQL error or connection string configuration error when saving the region settings. This could be a bug, it could also happen if ConnectionString is defined in the [DatabaseService] section of StandaloneCommon.ini in the config_include folder. This could also happen if the config_include folder doesn't exist or if the OpenSim.ini [Architecture] section isn't set. If this is your first time running OpenSimulator, please restart the simulator and bug a developer to fix this!", | ||
797 | SqlEx); | ||
798 | } | ||
799 | ds.AcceptChanges(); | ||
800 | } | ||
801 | } | ||
802 | |||
803 | /// <summary> | ||
804 | /// See <see cref="Commit"/> | ||
805 | /// </summary> | ||
806 | public void Shutdown() | ||
807 | { | ||
808 | Commit(); | ||
809 | } | ||
810 | |||
811 | /*********************************************************************** | ||
812 | * | ||
813 | * Database Definition Functions | ||
814 | * | ||
815 | * This should be db agnostic as we define them in ADO.NET terms | ||
816 | * | ||
817 | **********************************************************************/ | ||
818 | |||
819 | protected void CreateDataSetMapping(IDataAdapter da, string tableName) | ||
820 | { | ||
821 | ITableMapping dbMapping = da.TableMappings.Add(tableName, tableName); | ||
822 | foreach (DataColumn col in ds.Tables[tableName].Columns) | ||
823 | { | ||
824 | dbMapping.ColumnMappings.Add(col.ColumnName, col.ColumnName); | ||
825 | } | ||
826 | } | ||
827 | |||
828 | /// <summary> | ||
829 | /// | ||
830 | /// </summary> | ||
831 | /// <param name="dt"></param> | ||
832 | /// <param name="name"></param> | ||
833 | /// <param name="type"></param> | ||
834 | private static void createCol(DataTable dt, string name, Type type) | ||
835 | { | ||
836 | DataColumn col = new DataColumn(name, type); | ||
837 | dt.Columns.Add(col); | ||
838 | } | ||
839 | |||
840 | /// <summary> | ||
841 | /// Creates the "terrain" table | ||
842 | /// </summary> | ||
843 | /// <returns>terrain table DataTable</returns> | ||
844 | private static DataTable createTerrainTable() | ||
845 | { | ||
846 | DataTable terrain = new DataTable("terrain"); | ||
847 | |||
848 | createCol(terrain, "RegionUUID", typeof (String)); | ||
849 | createCol(terrain, "Revision", typeof (Int32)); | ||
850 | createCol(terrain, "Heightfield", typeof (Byte[])); | ||
851 | |||
852 | return terrain; | ||
853 | } | ||
854 | |||
855 | /// <summary> | ||
856 | /// Creates the "prims" table | ||
857 | /// </summary> | ||
858 | /// <returns>prim table DataTable</returns> | ||
859 | private static DataTable createPrimTable() | ||
860 | { | ||
861 | DataTable prims = new DataTable("prims"); | ||
862 | |||
863 | createCol(prims, "UUID", typeof (String)); | ||
864 | createCol(prims, "RegionUUID", typeof (String)); | ||
865 | createCol(prims, "CreationDate", typeof (Int32)); | ||
866 | createCol(prims, "Name", typeof (String)); | ||
867 | createCol(prims, "SceneGroupID", typeof (String)); | ||
868 | // various text fields | ||
869 | createCol(prims, "Text", typeof (String)); | ||
870 | createCol(prims, "ColorR", typeof (Int32)); | ||
871 | createCol(prims, "ColorG", typeof (Int32)); | ||
872 | createCol(prims, "ColorB", typeof (Int32)); | ||
873 | createCol(prims, "ColorA", typeof (Int32)); | ||
874 | createCol(prims, "Description", typeof (String)); | ||
875 | createCol(prims, "SitName", typeof (String)); | ||
876 | createCol(prims, "TouchName", typeof (String)); | ||
877 | // permissions | ||
878 | createCol(prims, "ObjectFlags", typeof (Int32)); | ||
879 | createCol(prims, "CreatorID", typeof (String)); | ||
880 | createCol(prims, "OwnerID", typeof (String)); | ||
881 | createCol(prims, "GroupID", typeof (String)); | ||
882 | createCol(prims, "LastOwnerID", typeof (String)); | ||
883 | createCol(prims, "OwnerMask", typeof (Int32)); | ||
884 | createCol(prims, "NextOwnerMask", typeof (Int32)); | ||
885 | createCol(prims, "GroupMask", typeof (Int32)); | ||
886 | createCol(prims, "EveryoneMask", typeof (Int32)); | ||
887 | createCol(prims, "BaseMask", typeof (Int32)); | ||
888 | // vectors | ||
889 | createCol(prims, "PositionX", typeof (Double)); | ||
890 | createCol(prims, "PositionY", typeof (Double)); | ||
891 | createCol(prims, "PositionZ", typeof (Double)); | ||
892 | createCol(prims, "GroupPositionX", typeof (Double)); | ||
893 | createCol(prims, "GroupPositionY", typeof (Double)); | ||
894 | createCol(prims, "GroupPositionZ", typeof (Double)); | ||
895 | createCol(prims, "VelocityX", typeof (Double)); | ||
896 | createCol(prims, "VelocityY", typeof (Double)); | ||
897 | createCol(prims, "VelocityZ", typeof (Double)); | ||
898 | createCol(prims, "AngularVelocityX", typeof (Double)); | ||
899 | createCol(prims, "AngularVelocityY", typeof (Double)); | ||
900 | createCol(prims, "AngularVelocityZ", typeof (Double)); | ||
901 | createCol(prims, "AccelerationX", typeof (Double)); | ||
902 | createCol(prims, "AccelerationY", typeof (Double)); | ||
903 | createCol(prims, "AccelerationZ", typeof (Double)); | ||
904 | // quaternions | ||
905 | createCol(prims, "RotationX", typeof (Double)); | ||
906 | createCol(prims, "RotationY", typeof (Double)); | ||
907 | createCol(prims, "RotationZ", typeof (Double)); | ||
908 | createCol(prims, "RotationW", typeof (Double)); | ||
909 | |||
910 | // sit target | ||
911 | createCol(prims, "SitTargetOffsetX", typeof (Double)); | ||
912 | createCol(prims, "SitTargetOffsetY", typeof (Double)); | ||
913 | createCol(prims, "SitTargetOffsetZ", typeof (Double)); | ||
914 | |||
915 | createCol(prims, "SitTargetOrientW", typeof (Double)); | ||
916 | createCol(prims, "SitTargetOrientX", typeof (Double)); | ||
917 | createCol(prims, "SitTargetOrientY", typeof (Double)); | ||
918 | createCol(prims, "SitTargetOrientZ", typeof (Double)); | ||
919 | |||
920 | createCol(prims, "PayPrice", typeof(Int32)); | ||
921 | createCol(prims, "PayButton1", typeof(Int32)); | ||
922 | createCol(prims, "PayButton2", typeof(Int32)); | ||
923 | createCol(prims, "PayButton3", typeof(Int32)); | ||
924 | createCol(prims, "PayButton4", typeof(Int32)); | ||
925 | |||
926 | createCol(prims, "LoopedSound", typeof(String)); | ||
927 | createCol(prims, "LoopedSoundGain", typeof(Double)); | ||
928 | createCol(prims, "TextureAnimation", typeof(String)); | ||
929 | createCol(prims, "ParticleSystem", typeof(String)); | ||
930 | |||
931 | createCol(prims, "OmegaX", typeof(Double)); | ||
932 | createCol(prims, "OmegaY", typeof(Double)); | ||
933 | createCol(prims, "OmegaZ", typeof(Double)); | ||
934 | |||
935 | createCol(prims, "CameraEyeOffsetX", typeof(Double)); | ||
936 | createCol(prims, "CameraEyeOffsetY", typeof(Double)); | ||
937 | createCol(prims, "CameraEyeOffsetZ", typeof(Double)); | ||
938 | |||
939 | createCol(prims, "CameraAtOffsetX", typeof(Double)); | ||
940 | createCol(prims, "CameraAtOffsetY", typeof(Double)); | ||
941 | createCol(prims, "CameraAtOffsetZ", typeof(Double)); | ||
942 | |||
943 | createCol(prims, "ForceMouselook", typeof(Int16)); | ||
944 | |||
945 | createCol(prims, "ScriptAccessPin", typeof(Int32)); | ||
946 | |||
947 | createCol(prims, "AllowedDrop", typeof(Int16)); | ||
948 | createCol(prims, "DieAtEdge", typeof(Int16)); | ||
949 | |||
950 | createCol(prims, "SalePrice", typeof(Int32)); | ||
951 | createCol(prims, "SaleType", typeof(Int16)); | ||
952 | |||
953 | // click action | ||
954 | createCol(prims, "ClickAction", typeof (Byte)); | ||
955 | |||
956 | createCol(prims, "Material", typeof(Byte)); | ||
957 | |||
958 | createCol(prims, "CollisionSound", typeof(String)); | ||
959 | createCol(prims, "CollisionSoundVolume", typeof(Double)); | ||
960 | |||
961 | createCol(prims, "VolumeDetect", typeof(Int16)); | ||
962 | |||
963 | // Add in contraints | ||
964 | prims.PrimaryKey = new DataColumn[] {prims.Columns["UUID"]}; | ||
965 | |||
966 | return prims; | ||
967 | } | ||
968 | |||
969 | /// <summary> | ||
970 | /// Creates "primshapes" table | ||
971 | /// </summary> | ||
972 | /// <returns>shape table DataTable</returns> | ||
973 | private static DataTable createShapeTable() | ||
974 | { | ||
975 | DataTable shapes = new DataTable("primshapes"); | ||
976 | createCol(shapes, "UUID", typeof (String)); | ||
977 | // shape is an enum | ||
978 | createCol(shapes, "Shape", typeof (Int32)); | ||
979 | // vectors | ||
980 | createCol(shapes, "ScaleX", typeof (Double)); | ||
981 | createCol(shapes, "ScaleY", typeof (Double)); | ||
982 | createCol(shapes, "ScaleZ", typeof (Double)); | ||
983 | // paths | ||
984 | createCol(shapes, "PCode", typeof (Int32)); | ||
985 | createCol(shapes, "PathBegin", typeof (Int32)); | ||
986 | createCol(shapes, "PathEnd", typeof (Int32)); | ||
987 | createCol(shapes, "PathScaleX", typeof (Int32)); | ||
988 | createCol(shapes, "PathScaleY", typeof (Int32)); | ||
989 | createCol(shapes, "PathShearX", typeof (Int32)); | ||
990 | createCol(shapes, "PathShearY", typeof (Int32)); | ||
991 | createCol(shapes, "PathSkew", typeof (Int32)); | ||
992 | createCol(shapes, "PathCurve", typeof (Int32)); | ||
993 | createCol(shapes, "PathRadiusOffset", typeof (Int32)); | ||
994 | createCol(shapes, "PathRevolutions", typeof (Int32)); | ||
995 | createCol(shapes, "PathTaperX", typeof (Int32)); | ||
996 | createCol(shapes, "PathTaperY", typeof (Int32)); | ||
997 | createCol(shapes, "PathTwist", typeof (Int32)); | ||
998 | createCol(shapes, "PathTwistBegin", typeof (Int32)); | ||
999 | // profile | ||
1000 | createCol(shapes, "ProfileBegin", typeof (Int32)); | ||
1001 | createCol(shapes, "ProfileEnd", typeof (Int32)); | ||
1002 | createCol(shapes, "ProfileCurve", typeof (Int32)); | ||
1003 | createCol(shapes, "ProfileHollow", typeof (Int32)); | ||
1004 | createCol(shapes, "State", typeof(Int32)); | ||
1005 | // text TODO: this isn't right, but I'm not sure the right | ||
1006 | // way to specify this as a blob atm | ||
1007 | createCol(shapes, "Texture", typeof (Byte[])); | ||
1008 | createCol(shapes, "ExtraParams", typeof (Byte[])); | ||
1009 | |||
1010 | shapes.PrimaryKey = new DataColumn[] {shapes.Columns["UUID"]}; | ||
1011 | |||
1012 | return shapes; | ||
1013 | } | ||
1014 | |||
1015 | /// <summary> | ||
1016 | /// creates "primitems" table | ||
1017 | /// </summary> | ||
1018 | /// <returns>item table DataTable</returns> | ||
1019 | private static DataTable createItemsTable() | ||
1020 | { | ||
1021 | DataTable items = new DataTable("primitems"); | ||
1022 | |||
1023 | createCol(items, "itemID", typeof (String)); | ||
1024 | createCol(items, "primID", typeof (String)); | ||
1025 | createCol(items, "assetID", typeof (String)); | ||
1026 | createCol(items, "parentFolderID", typeof (String)); | ||
1027 | |||
1028 | createCol(items, "invType", typeof (Int32)); | ||
1029 | createCol(items, "assetType", typeof (Int32)); | ||
1030 | |||
1031 | createCol(items, "name", typeof (String)); | ||
1032 | createCol(items, "description", typeof (String)); | ||
1033 | |||
1034 | createCol(items, "creationDate", typeof (Int64)); | ||
1035 | createCol(items, "creatorID", typeof (String)); | ||
1036 | createCol(items, "ownerID", typeof (String)); | ||
1037 | createCol(items, "lastOwnerID", typeof (String)); | ||
1038 | createCol(items, "groupID", typeof (String)); | ||
1039 | |||
1040 | createCol(items, "nextPermissions", typeof (UInt32)); | ||
1041 | createCol(items, "currentPermissions", typeof (UInt32)); | ||
1042 | createCol(items, "basePermissions", typeof (UInt32)); | ||
1043 | createCol(items, "everyonePermissions", typeof (UInt32)); | ||
1044 | createCol(items, "groupPermissions", typeof (UInt32)); | ||
1045 | createCol(items, "flags", typeof (UInt32)); | ||
1046 | |||
1047 | items.PrimaryKey = new DataColumn[] { items.Columns["itemID"] }; | ||
1048 | |||
1049 | return items; | ||
1050 | } | ||
1051 | |||
1052 | /// <summary> | ||
1053 | /// Creates "land" table | ||
1054 | /// </summary> | ||
1055 | /// <returns>land table DataTable</returns> | ||
1056 | private static DataTable createLandTable() | ||
1057 | { | ||
1058 | DataTable land = new DataTable("land"); | ||
1059 | createCol(land, "UUID", typeof (String)); | ||
1060 | createCol(land, "RegionUUID", typeof (String)); | ||
1061 | createCol(land, "LocalLandID", typeof (UInt32)); | ||
1062 | |||
1063 | // Bitmap is a byte[512] | ||
1064 | createCol(land, "Bitmap", typeof (Byte[])); | ||
1065 | |||
1066 | createCol(land, "Name", typeof (String)); | ||
1067 | createCol(land, "Desc", typeof (String)); | ||
1068 | createCol(land, "OwnerUUID", typeof (String)); | ||
1069 | createCol(land, "IsGroupOwned", typeof (Boolean)); | ||
1070 | createCol(land, "Area", typeof (Int32)); | ||
1071 | createCol(land, "AuctionID", typeof (Int32)); //Unemplemented | ||
1072 | createCol(land, "Category", typeof (Int32)); //Enum OpenMetaverse.Parcel.ParcelCategory | ||
1073 | createCol(land, "ClaimDate", typeof (Int32)); | ||
1074 | createCol(land, "ClaimPrice", typeof (Int32)); | ||
1075 | createCol(land, "GroupUUID", typeof (string)); | ||
1076 | createCol(land, "SalePrice", typeof (Int32)); | ||
1077 | createCol(land, "LandStatus", typeof (Int32)); //Enum. OpenMetaverse.Parcel.ParcelStatus | ||
1078 | createCol(land, "LandFlags", typeof (UInt32)); | ||
1079 | createCol(land, "LandingType", typeof (Byte)); | ||
1080 | createCol(land, "MediaAutoScale", typeof (Byte)); | ||
1081 | createCol(land, "MediaTextureUUID", typeof (String)); | ||
1082 | createCol(land, "MediaURL", typeof (String)); | ||
1083 | createCol(land, "MusicURL", typeof (String)); | ||
1084 | createCol(land, "PassHours", typeof (Double)); | ||
1085 | createCol(land, "PassPrice", typeof (UInt32)); | ||
1086 | createCol(land, "SnapshotUUID", typeof (String)); | ||
1087 | createCol(land, "UserLocationX", typeof (Double)); | ||
1088 | createCol(land, "UserLocationY", typeof (Double)); | ||
1089 | createCol(land, "UserLocationZ", typeof (Double)); | ||
1090 | createCol(land, "UserLookAtX", typeof (Double)); | ||
1091 | createCol(land, "UserLookAtY", typeof (Double)); | ||
1092 | createCol(land, "UserLookAtZ", typeof (Double)); | ||
1093 | createCol(land, "AuthbuyerID", typeof(String)); | ||
1094 | createCol(land, "OtherCleanTime", typeof(Int32)); | ||
1095 | createCol(land, "Dwell", typeof(Int32)); | ||
1096 | |||
1097 | land.PrimaryKey = new DataColumn[] {land.Columns["UUID"]}; | ||
1098 | |||
1099 | return land; | ||
1100 | } | ||
1101 | |||
1102 | /// <summary> | ||
1103 | /// create "landaccesslist" table | ||
1104 | /// </summary> | ||
1105 | /// <returns>Landacceslist DataTable</returns> | ||
1106 | private static DataTable createLandAccessListTable() | ||
1107 | { | ||
1108 | DataTable landaccess = new DataTable("landaccesslist"); | ||
1109 | createCol(landaccess, "LandUUID", typeof (String)); | ||
1110 | createCol(landaccess, "AccessUUID", typeof (String)); | ||
1111 | createCol(landaccess, "Flags", typeof (UInt32)); | ||
1112 | |||
1113 | return landaccess; | ||
1114 | } | ||
1115 | |||
1116 | private static DataTable createRegionSettingsTable() | ||
1117 | { | ||
1118 | DataTable regionsettings = new DataTable("regionsettings"); | ||
1119 | createCol(regionsettings, "regionUUID", typeof(String)); | ||
1120 | createCol(regionsettings, "block_terraform", typeof (Int32)); | ||
1121 | createCol(regionsettings, "block_fly", typeof (Int32)); | ||
1122 | createCol(regionsettings, "allow_damage", typeof (Int32)); | ||
1123 | createCol(regionsettings, "restrict_pushing", typeof (Int32)); | ||
1124 | createCol(regionsettings, "allow_land_resell", typeof (Int32)); | ||
1125 | createCol(regionsettings, "allow_land_join_divide", typeof (Int32)); | ||
1126 | createCol(regionsettings, "block_show_in_search", typeof (Int32)); | ||
1127 | createCol(regionsettings, "agent_limit", typeof (Int32)); | ||
1128 | createCol(regionsettings, "object_bonus", typeof (Double)); | ||
1129 | createCol(regionsettings, "maturity", typeof (Int32)); | ||
1130 | createCol(regionsettings, "disable_scripts", typeof (Int32)); | ||
1131 | createCol(regionsettings, "disable_collisions", typeof (Int32)); | ||
1132 | createCol(regionsettings, "disable_physics", typeof (Int32)); | ||
1133 | createCol(regionsettings, "terrain_texture_1", typeof(String)); | ||
1134 | createCol(regionsettings, "terrain_texture_2", typeof(String)); | ||
1135 | createCol(regionsettings, "terrain_texture_3", typeof(String)); | ||
1136 | createCol(regionsettings, "terrain_texture_4", typeof(String)); | ||
1137 | createCol(regionsettings, "elevation_1_nw", typeof (Double)); | ||
1138 | createCol(regionsettings, "elevation_2_nw", typeof (Double)); | ||
1139 | createCol(regionsettings, "elevation_1_ne", typeof (Double)); | ||
1140 | createCol(regionsettings, "elevation_2_ne", typeof (Double)); | ||
1141 | createCol(regionsettings, "elevation_1_se", typeof (Double)); | ||
1142 | createCol(regionsettings, "elevation_2_se", typeof (Double)); | ||
1143 | createCol(regionsettings, "elevation_1_sw", typeof (Double)); | ||
1144 | createCol(regionsettings, "elevation_2_sw", typeof (Double)); | ||
1145 | createCol(regionsettings, "water_height", typeof (Double)); | ||
1146 | createCol(regionsettings, "terrain_raise_limit", typeof (Double)); | ||
1147 | createCol(regionsettings, "terrain_lower_limit", typeof (Double)); | ||
1148 | createCol(regionsettings, "use_estate_sun", typeof (Int32)); | ||
1149 | createCol(regionsettings, "sandbox", typeof (Int32)); | ||
1150 | createCol(regionsettings, "sunvectorx",typeof (Double)); | ||
1151 | createCol(regionsettings, "sunvectory",typeof (Double)); | ||
1152 | createCol(regionsettings, "sunvectorz",typeof (Double)); | ||
1153 | createCol(regionsettings, "fixed_sun", typeof (Int32)); | ||
1154 | createCol(regionsettings, "sun_position", typeof (Double)); | ||
1155 | createCol(regionsettings, "covenant", typeof(String)); | ||
1156 | regionsettings.PrimaryKey = new DataColumn[] { regionsettings.Columns["regionUUID"] }; | ||
1157 | return regionsettings; | ||
1158 | } | ||
1159 | |||
1160 | /*********************************************************************** | ||
1161 | * | ||
1162 | * Convert between ADO.NET <=> OpenSim Objects | ||
1163 | * | ||
1164 | * These should be database independant | ||
1165 | * | ||
1166 | **********************************************************************/ | ||
1167 | |||
1168 | /// <summary> | ||
1169 | /// | ||
1170 | /// </summary> | ||
1171 | /// <param name="row"></param> | ||
1172 | /// <returns></returns> | ||
1173 | private SceneObjectPart buildPrim(DataRow row) | ||
1174 | { | ||
1175 | // Code commented. Uncomment to test the unit test inline. | ||
1176 | |||
1177 | // The unit test mentions this commented code for the purposes | ||
1178 | // of debugging a unit test failure | ||
1179 | |||
1180 | // SceneObjectGroup sog = new SceneObjectGroup(); | ||
1181 | // SceneObjectPart sop = new SceneObjectPart(); | ||
1182 | // sop.LocalId = 1; | ||
1183 | // sop.Name = "object1"; | ||
1184 | // sop.Description = "object1"; | ||
1185 | // sop.Text = ""; | ||
1186 | // sop.SitName = ""; | ||
1187 | // sop.TouchName = ""; | ||
1188 | // sop.UUID = UUID.Random(); | ||
1189 | // sop.Shape = PrimitiveBaseShape.Default; | ||
1190 | // sog.SetRootPart(sop); | ||
1191 | // Add breakpoint in above line. Check sop fields. | ||
1192 | |||
1193 | // TODO: this doesn't work yet because something more | ||
1194 | // interesting has to be done to actually get these values | ||
1195 | // back out. Not enough time to figure it out yet. | ||
1196 | |||
1197 | SceneObjectPart prim = new SceneObjectPart(); | ||
1198 | prim.UUID = new UUID((String) row["UUID"]); | ||
1199 | // explicit conversion of integers is required, which sort | ||
1200 | // of sucks. No idea if there is a shortcut here or not. | ||
1201 | prim.CreationDate = Convert.ToInt32(row["CreationDate"]); | ||
1202 | prim.Name = row["Name"] == DBNull.Value ? string.Empty : (string)row["Name"]; | ||
1203 | // various text fields | ||
1204 | prim.Text = (String) row["Text"]; | ||
1205 | prim.Color = Color.FromArgb(Convert.ToInt32(row["ColorA"]), | ||
1206 | Convert.ToInt32(row["ColorR"]), | ||
1207 | Convert.ToInt32(row["ColorG"]), | ||
1208 | Convert.ToInt32(row["ColorB"])); | ||
1209 | prim.Description = (String) row["Description"]; | ||
1210 | prim.SitName = (String) row["SitName"]; | ||
1211 | prim.TouchName = (String) row["TouchName"]; | ||
1212 | // permissions | ||
1213 | prim.ObjectFlags = Convert.ToUInt32(row["ObjectFlags"]); | ||
1214 | prim.CreatorID = new UUID((String) row["CreatorID"]); | ||
1215 | prim.OwnerID = new UUID((String) row["OwnerID"]); | ||
1216 | prim.GroupID = new UUID((String) row["GroupID"]); | ||
1217 | prim.LastOwnerID = new UUID((String) row["LastOwnerID"]); | ||
1218 | prim.OwnerMask = Convert.ToUInt32(row["OwnerMask"]); | ||
1219 | prim.NextOwnerMask = Convert.ToUInt32(row["NextOwnerMask"]); | ||
1220 | prim.GroupMask = Convert.ToUInt32(row["GroupMask"]); | ||
1221 | prim.EveryoneMask = Convert.ToUInt32(row["EveryoneMask"]); | ||
1222 | prim.BaseMask = Convert.ToUInt32(row["BaseMask"]); | ||
1223 | // vectors | ||
1224 | prim.OffsetPosition = new Vector3( | ||
1225 | Convert.ToSingle(row["PositionX"]), | ||
1226 | Convert.ToSingle(row["PositionY"]), | ||
1227 | Convert.ToSingle(row["PositionZ"]) | ||
1228 | ); | ||
1229 | prim.GroupPosition = new Vector3( | ||
1230 | Convert.ToSingle(row["GroupPositionX"]), | ||
1231 | Convert.ToSingle(row["GroupPositionY"]), | ||
1232 | Convert.ToSingle(row["GroupPositionZ"]) | ||
1233 | ); | ||
1234 | prim.Velocity = new Vector3( | ||
1235 | Convert.ToSingle(row["VelocityX"]), | ||
1236 | Convert.ToSingle(row["VelocityY"]), | ||
1237 | Convert.ToSingle(row["VelocityZ"]) | ||
1238 | ); | ||
1239 | prim.AngularVelocity = new Vector3( | ||
1240 | Convert.ToSingle(row["AngularVelocityX"]), | ||
1241 | Convert.ToSingle(row["AngularVelocityY"]), | ||
1242 | Convert.ToSingle(row["AngularVelocityZ"]) | ||
1243 | ); | ||
1244 | prim.Acceleration = new Vector3( | ||
1245 | Convert.ToSingle(row["AccelerationX"]), | ||
1246 | Convert.ToSingle(row["AccelerationY"]), | ||
1247 | Convert.ToSingle(row["AccelerationZ"]) | ||
1248 | ); | ||
1249 | // quaternions | ||
1250 | prim.RotationOffset = new Quaternion( | ||
1251 | Convert.ToSingle(row["RotationX"]), | ||
1252 | Convert.ToSingle(row["RotationY"]), | ||
1253 | Convert.ToSingle(row["RotationZ"]), | ||
1254 | Convert.ToSingle(row["RotationW"]) | ||
1255 | ); | ||
1256 | |||
1257 | prim.SitTargetPositionLL = new Vector3( | ||
1258 | Convert.ToSingle(row["SitTargetOffsetX"]), | ||
1259 | Convert.ToSingle(row["SitTargetOffsetY"]), | ||
1260 | Convert.ToSingle(row["SitTargetOffsetZ"])); | ||
1261 | prim.SitTargetOrientationLL = new Quaternion( | ||
1262 | Convert.ToSingle( | ||
1263 | row["SitTargetOrientX"]), | ||
1264 | Convert.ToSingle( | ||
1265 | row["SitTargetOrientY"]), | ||
1266 | Convert.ToSingle( | ||
1267 | row["SitTargetOrientZ"]), | ||
1268 | Convert.ToSingle( | ||
1269 | row["SitTargetOrientW"])); | ||
1270 | |||
1271 | prim.ClickAction = Convert.ToByte(row["ClickAction"]); | ||
1272 | prim.PayPrice[0] = Convert.ToInt32(row["PayPrice"]); | ||
1273 | prim.PayPrice[1] = Convert.ToInt32(row["PayButton1"]); | ||
1274 | prim.PayPrice[2] = Convert.ToInt32(row["PayButton2"]); | ||
1275 | prim.PayPrice[3] = Convert.ToInt32(row["PayButton3"]); | ||
1276 | prim.PayPrice[4] = Convert.ToInt32(row["PayButton4"]); | ||
1277 | |||
1278 | prim.Sound = new UUID(row["LoopedSound"].ToString()); | ||
1279 | prim.SoundGain = Convert.ToSingle(row["LoopedSoundGain"]); | ||
1280 | prim.SoundFlags = 1; // If it's persisted at all, it's looped | ||
1281 | |||
1282 | if (!row.IsNull("TextureAnimation")) | ||
1283 | prim.TextureAnimation = Convert.FromBase64String(row["TextureAnimation"].ToString()); | ||
1284 | if (!row.IsNull("ParticleSystem")) | ||
1285 | prim.ParticleSystem = Convert.FromBase64String(row["ParticleSystem"].ToString()); | ||
1286 | |||
1287 | prim.AngularVelocity = new Vector3( | ||
1288 | Convert.ToSingle(row["OmegaX"]), | ||
1289 | Convert.ToSingle(row["OmegaY"]), | ||
1290 | Convert.ToSingle(row["OmegaZ"]) | ||
1291 | ); | ||
1292 | |||
1293 | prim.SetCameraEyeOffset(new Vector3( | ||
1294 | Convert.ToSingle(row["CameraEyeOffsetX"]), | ||
1295 | Convert.ToSingle(row["CameraEyeOffsetY"]), | ||
1296 | Convert.ToSingle(row["CameraEyeOffsetZ"]) | ||
1297 | )); | ||
1298 | |||
1299 | prim.SetCameraAtOffset(new Vector3( | ||
1300 | Convert.ToSingle(row["CameraAtOffsetX"]), | ||
1301 | Convert.ToSingle(row["CameraAtOffsetY"]), | ||
1302 | Convert.ToSingle(row["CameraAtOffsetZ"]) | ||
1303 | )); | ||
1304 | |||
1305 | if (Convert.ToInt16(row["ForceMouselook"]) != 0) | ||
1306 | prim.SetForceMouselook(true); | ||
1307 | |||
1308 | prim.ScriptAccessPin = Convert.ToInt32(row["ScriptAccessPin"]); | ||
1309 | |||
1310 | if (Convert.ToInt16(row["AllowedDrop"]) != 0) | ||
1311 | prim.AllowedDrop = true; | ||
1312 | |||
1313 | if (Convert.ToInt16(row["DieAtEdge"]) != 0) | ||
1314 | prim.DIE_AT_EDGE = true; | ||
1315 | |||
1316 | prim.SalePrice = Convert.ToInt32(row["SalePrice"]); | ||
1317 | prim.ObjectSaleType = Convert.ToByte(row["SaleType"]); | ||
1318 | |||
1319 | prim.Material = Convert.ToByte(row["Material"]); | ||
1320 | |||
1321 | prim.CollisionSound = new UUID(row["CollisionSound"].ToString()); | ||
1322 | prim.CollisionSoundVolume = Convert.ToSingle(row["CollisionSoundVolume"]); | ||
1323 | |||
1324 | if (Convert.ToInt16(row["VolumeDetect"]) != 0) | ||
1325 | prim.VolumeDetectActive = true; | ||
1326 | |||
1327 | return prim; | ||
1328 | } | ||
1329 | |||
1330 | /// <summary> | ||
1331 | /// Build a prim inventory item from the persisted data. | ||
1332 | /// </summary> | ||
1333 | /// <param name="row"></param> | ||
1334 | /// <returns></returns> | ||
1335 | private static TaskInventoryItem buildItem(DataRow row) | ||
1336 | { | ||
1337 | TaskInventoryItem taskItem = new TaskInventoryItem(); | ||
1338 | |||
1339 | taskItem.ItemID = new UUID((String)row["itemID"]); | ||
1340 | taskItem.ParentPartID = new UUID((String)row["primID"]); | ||
1341 | taskItem.AssetID = new UUID((String)row["assetID"]); | ||
1342 | taskItem.ParentID = new UUID((String)row["parentFolderID"]); | ||
1343 | |||
1344 | taskItem.InvType = Convert.ToInt32(row["invType"]); | ||
1345 | taskItem.Type = Convert.ToInt32(row["assetType"]); | ||
1346 | |||
1347 | taskItem.Name = (String)row["name"]; | ||
1348 | taskItem.Description = (String)row["description"]; | ||
1349 | taskItem.CreationDate = Convert.ToUInt32(row["creationDate"]); | ||
1350 | taskItem.CreatorID = new UUID((String)row["creatorID"]); | ||
1351 | taskItem.OwnerID = new UUID((String)row["ownerID"]); | ||
1352 | taskItem.LastOwnerID = new UUID((String)row["lastOwnerID"]); | ||
1353 | taskItem.GroupID = new UUID((String)row["groupID"]); | ||
1354 | |||
1355 | taskItem.NextPermissions = Convert.ToUInt32(row["nextPermissions"]); | ||
1356 | taskItem.CurrentPermissions = Convert.ToUInt32(row["currentPermissions"]); | ||
1357 | taskItem.BasePermissions = Convert.ToUInt32(row["basePermissions"]); | ||
1358 | taskItem.EveryonePermissions = Convert.ToUInt32(row["everyonePermissions"]); | ||
1359 | taskItem.GroupPermissions = Convert.ToUInt32(row["groupPermissions"]); | ||
1360 | taskItem.Flags = Convert.ToUInt32(row["flags"]); | ||
1361 | |||
1362 | return taskItem; | ||
1363 | } | ||
1364 | |||
1365 | /// <summary> | ||
1366 | /// Build a Land Data from the persisted data. | ||
1367 | /// </summary> | ||
1368 | /// <param name="row"></param> | ||
1369 | /// <returns></returns> | ||
1370 | private LandData buildLandData(DataRow row) | ||
1371 | { | ||
1372 | LandData newData = new LandData(); | ||
1373 | |||
1374 | newData.GlobalID = new UUID((String) row["UUID"]); | ||
1375 | newData.LocalID = Convert.ToInt32(row["LocalLandID"]); | ||
1376 | |||
1377 | // Bitmap is a byte[512] | ||
1378 | newData.Bitmap = (Byte[]) row["Bitmap"]; | ||
1379 | |||
1380 | newData.Name = (String) row["Name"]; | ||
1381 | newData.Description = (String) row["Desc"]; | ||
1382 | newData.OwnerID = (UUID)(String) row["OwnerUUID"]; | ||
1383 | newData.IsGroupOwned = (Boolean) row["IsGroupOwned"]; | ||
1384 | newData.Area = Convert.ToInt32(row["Area"]); | ||
1385 | newData.AuctionID = Convert.ToUInt32(row["AuctionID"]); //Unemplemented | ||
1386 | newData.Category = (ParcelCategory) Convert.ToInt32(row["Category"]); | ||
1387 | //Enum OpenMetaverse.Parcel.ParcelCategory | ||
1388 | newData.ClaimDate = Convert.ToInt32(row["ClaimDate"]); | ||
1389 | newData.ClaimPrice = Convert.ToInt32(row["ClaimPrice"]); | ||
1390 | newData.GroupID = new UUID((String) row["GroupUUID"]); | ||
1391 | newData.SalePrice = Convert.ToInt32(row["SalePrice"]); | ||
1392 | newData.Status = (ParcelStatus) Convert.ToInt32(row["LandStatus"]); | ||
1393 | //Enum. OpenMetaverse.Parcel.ParcelStatus | ||
1394 | newData.Flags = Convert.ToUInt32(row["LandFlags"]); | ||
1395 | newData.LandingType = (Byte) row["LandingType"]; | ||
1396 | newData.MediaAutoScale = (Byte) row["MediaAutoScale"]; | ||
1397 | newData.MediaID = new UUID((String) row["MediaTextureUUID"]); | ||
1398 | newData.MediaURL = (String) row["MediaURL"]; | ||
1399 | newData.MusicURL = (String) row["MusicURL"]; | ||
1400 | newData.PassHours = Convert.ToSingle(row["PassHours"]); | ||
1401 | newData.PassPrice = Convert.ToInt32(row["PassPrice"]); | ||
1402 | newData.SnapshotID = (UUID)(String) row["SnapshotUUID"]; | ||
1403 | try | ||
1404 | { | ||
1405 | |||
1406 | newData.UserLocation = | ||
1407 | new Vector3(Convert.ToSingle(row["UserLocationX"]), Convert.ToSingle(row["UserLocationY"]), | ||
1408 | Convert.ToSingle(row["UserLocationZ"])); | ||
1409 | newData.UserLookAt = | ||
1410 | new Vector3(Convert.ToSingle(row["UserLookAtX"]), Convert.ToSingle(row["UserLookAtY"]), | ||
1411 | Convert.ToSingle(row["UserLookAtZ"])); | ||
1412 | |||
1413 | } | ||
1414 | catch (InvalidCastException) | ||
1415 | { | ||
1416 | m_log.ErrorFormat("[PARCEL]: unable to get parcel telehub settings for {1}", newData.Name); | ||
1417 | newData.UserLocation = Vector3.Zero; | ||
1418 | newData.UserLookAt = Vector3.Zero; | ||
1419 | } | ||
1420 | newData.ParcelAccessList = new List<ParcelManager.ParcelAccessEntry>(); | ||
1421 | UUID authBuyerID = UUID.Zero; | ||
1422 | |||
1423 | UUID.TryParse((string)row["AuthbuyerID"], out authBuyerID); | ||
1424 | |||
1425 | newData.OtherCleanTime = Convert.ToInt32(row["OtherCleanTime"]); | ||
1426 | newData.Dwell = Convert.ToInt32(row["Dwell"]); | ||
1427 | |||
1428 | return newData; | ||
1429 | } | ||
1430 | |||
1431 | private RegionSettings buildRegionSettings(DataRow row) | ||
1432 | { | ||
1433 | RegionSettings newSettings = new RegionSettings(); | ||
1434 | |||
1435 | newSettings.RegionUUID = new UUID((string) row["regionUUID"]); | ||
1436 | newSettings.BlockTerraform = Convert.ToBoolean(row["block_terraform"]); | ||
1437 | newSettings.AllowDamage = Convert.ToBoolean(row["allow_damage"]); | ||
1438 | newSettings.BlockFly = Convert.ToBoolean(row["block_fly"]); | ||
1439 | newSettings.RestrictPushing = Convert.ToBoolean(row["restrict_pushing"]); | ||
1440 | newSettings.AllowLandResell = Convert.ToBoolean(row["allow_land_resell"]); | ||
1441 | newSettings.AllowLandJoinDivide = Convert.ToBoolean(row["allow_land_join_divide"]); | ||
1442 | newSettings.BlockShowInSearch = Convert.ToBoolean(row["block_show_in_search"]); | ||
1443 | newSettings.AgentLimit = Convert.ToInt32(row["agent_limit"]); | ||
1444 | newSettings.ObjectBonus = Convert.ToDouble(row["object_bonus"]); | ||
1445 | newSettings.Maturity = Convert.ToInt32(row["maturity"]); | ||
1446 | newSettings.DisableScripts = Convert.ToBoolean(row["disable_scripts"]); | ||
1447 | newSettings.DisableCollisions = Convert.ToBoolean(row["disable_collisions"]); | ||
1448 | newSettings.DisablePhysics = Convert.ToBoolean(row["disable_physics"]); | ||
1449 | newSettings.TerrainTexture1 = new UUID((String) row["terrain_texture_1"]); | ||
1450 | newSettings.TerrainTexture2 = new UUID((String) row["terrain_texture_2"]); | ||
1451 | newSettings.TerrainTexture3 = new UUID((String) row["terrain_texture_3"]); | ||
1452 | newSettings.TerrainTexture4 = new UUID((String) row["terrain_texture_4"]); | ||
1453 | newSettings.Elevation1NW = Convert.ToDouble(row["elevation_1_nw"]); | ||
1454 | newSettings.Elevation2NW = Convert.ToDouble(row["elevation_2_nw"]); | ||
1455 | newSettings.Elevation1NE = Convert.ToDouble(row["elevation_1_ne"]); | ||
1456 | newSettings.Elevation2NE = Convert.ToDouble(row["elevation_2_ne"]); | ||
1457 | newSettings.Elevation1SE = Convert.ToDouble(row["elevation_1_se"]); | ||
1458 | newSettings.Elevation2SE = Convert.ToDouble(row["elevation_2_se"]); | ||
1459 | newSettings.Elevation1SW = Convert.ToDouble(row["elevation_1_sw"]); | ||
1460 | newSettings.Elevation2SW = Convert.ToDouble(row["elevation_2_sw"]); | ||
1461 | newSettings.WaterHeight = Convert.ToDouble(row["water_height"]); | ||
1462 | newSettings.TerrainRaiseLimit = Convert.ToDouble(row["terrain_raise_limit"]); | ||
1463 | newSettings.TerrainLowerLimit = Convert.ToDouble(row["terrain_lower_limit"]); | ||
1464 | newSettings.UseEstateSun = Convert.ToBoolean(row["use_estate_sun"]); | ||
1465 | newSettings.Sandbox = Convert.ToBoolean(row["sandbox"]); | ||
1466 | newSettings.SunVector = new Vector3 ( | ||
1467 | Convert.ToSingle(row["sunvectorx"]), | ||
1468 | Convert.ToSingle(row["sunvectory"]), | ||
1469 | Convert.ToSingle(row["sunvectorz"]) | ||
1470 | ); | ||
1471 | newSettings.FixedSun = Convert.ToBoolean(row["fixed_sun"]); | ||
1472 | newSettings.SunPosition = Convert.ToDouble(row["sun_position"]); | ||
1473 | newSettings.Covenant = new UUID((String) row["covenant"]); | ||
1474 | |||
1475 | return newSettings; | ||
1476 | } | ||
1477 | |||
1478 | /// <summary> | ||
1479 | /// Build a land access entry from the persisted data. | ||
1480 | /// </summary> | ||
1481 | /// <param name="row"></param> | ||
1482 | /// <returns></returns> | ||
1483 | private static ParcelManager.ParcelAccessEntry buildLandAccessData(DataRow row) | ||
1484 | { | ||
1485 | ParcelManager.ParcelAccessEntry entry = new ParcelManager.ParcelAccessEntry(); | ||
1486 | entry.AgentID = new UUID((string) row["AccessUUID"]); | ||
1487 | entry.Flags = (AccessList) row["Flags"]; | ||
1488 | entry.Time = new DateTime(); | ||
1489 | return entry; | ||
1490 | } | ||
1491 | |||
1492 | /// <summary> | ||
1493 | /// | ||
1494 | /// </summary> | ||
1495 | /// <param name="val"></param> | ||
1496 | /// <returns></returns> | ||
1497 | private static Array serializeTerrain(double[,] val) | ||
1498 | { | ||
1499 | MemoryStream str = new MemoryStream(((int)Constants.RegionSize * (int)Constants.RegionSize) *sizeof (double)); | ||
1500 | BinaryWriter bw = new BinaryWriter(str); | ||
1501 | |||
1502 | // TODO: COMPATIBILITY - Add byte-order conversions | ||
1503 | for (int x = 0; x < (int)Constants.RegionSize; x++) | ||
1504 | for (int y = 0; y < (int)Constants.RegionSize; y++) | ||
1505 | bw.Write(val[x, y]); | ||
1506 | |||
1507 | return str.ToArray(); | ||
1508 | } | ||
1509 | |||
1510 | // private void fillTerrainRow(DataRow row, UUID regionUUID, int rev, double[,] val) | ||
1511 | // { | ||
1512 | // row["RegionUUID"] = regionUUID; | ||
1513 | // row["Revision"] = rev; | ||
1514 | |||
1515 | // MemoryStream str = new MemoryStream(((int)Constants.RegionSize * (int)Constants.RegionSize)*sizeof (double)); | ||
1516 | // BinaryWriter bw = new BinaryWriter(str); | ||
1517 | |||
1518 | // // TODO: COMPATIBILITY - Add byte-order conversions | ||
1519 | // for (int x = 0; x < (int)Constants.RegionSize; x++) | ||
1520 | // for (int y = 0; y < (int)Constants.RegionSize; y++) | ||
1521 | // bw.Write(val[x, y]); | ||
1522 | |||
1523 | // row["Heightfield"] = str.ToArray(); | ||
1524 | // } | ||
1525 | |||
1526 | /// <summary> | ||
1527 | /// | ||
1528 | /// </summary> | ||
1529 | /// <param name="row"></param> | ||
1530 | /// <param name="prim"></param> | ||
1531 | /// <param name="sceneGroupID"></param> | ||
1532 | /// <param name="regionUUID"></param> | ||
1533 | private static void fillPrimRow(DataRow row, SceneObjectPart prim, UUID sceneGroupID, UUID regionUUID) | ||
1534 | { | ||
1535 | row["UUID"] = prim.UUID.ToString(); | ||
1536 | row["RegionUUID"] = regionUUID.ToString(); | ||
1537 | row["CreationDate"] = prim.CreationDate; | ||
1538 | row["Name"] = prim.Name; | ||
1539 | row["SceneGroupID"] = sceneGroupID.ToString(); | ||
1540 | // the UUID of the root part for this SceneObjectGroup | ||
1541 | // various text fields | ||
1542 | row["Text"] = prim.Text; | ||
1543 | row["Description"] = prim.Description; | ||
1544 | row["SitName"] = prim.SitName; | ||
1545 | row["TouchName"] = prim.TouchName; | ||
1546 | // permissions | ||
1547 | row["ObjectFlags"] = prim.ObjectFlags; | ||
1548 | row["CreatorID"] = prim.CreatorID.ToString(); | ||
1549 | row["OwnerID"] = prim.OwnerID.ToString(); | ||
1550 | row["GroupID"] = prim.GroupID.ToString(); | ||
1551 | row["LastOwnerID"] = prim.LastOwnerID.ToString(); | ||
1552 | row["OwnerMask"] = prim.OwnerMask; | ||
1553 | row["NextOwnerMask"] = prim.NextOwnerMask; | ||
1554 | row["GroupMask"] = prim.GroupMask; | ||
1555 | row["EveryoneMask"] = prim.EveryoneMask; | ||
1556 | row["BaseMask"] = prim.BaseMask; | ||
1557 | // vectors | ||
1558 | row["PositionX"] = prim.OffsetPosition.X; | ||
1559 | row["PositionY"] = prim.OffsetPosition.Y; | ||
1560 | row["PositionZ"] = prim.OffsetPosition.Z; | ||
1561 | row["GroupPositionX"] = prim.GroupPosition.X; | ||
1562 | row["GroupPositionY"] = prim.GroupPosition.Y; | ||
1563 | row["GroupPositionZ"] = prim.GroupPosition.Z; | ||
1564 | row["VelocityX"] = prim.Velocity.X; | ||
1565 | row["VelocityY"] = prim.Velocity.Y; | ||
1566 | row["VelocityZ"] = prim.Velocity.Z; | ||
1567 | row["AngularVelocityX"] = prim.AngularVelocity.X; | ||
1568 | row["AngularVelocityY"] = prim.AngularVelocity.Y; | ||
1569 | row["AngularVelocityZ"] = prim.AngularVelocity.Z; | ||
1570 | row["AccelerationX"] = prim.Acceleration.X; | ||
1571 | row["AccelerationY"] = prim.Acceleration.Y; | ||
1572 | row["AccelerationZ"] = prim.Acceleration.Z; | ||
1573 | // quaternions | ||
1574 | row["RotationX"] = prim.RotationOffset.X; | ||
1575 | row["RotationY"] = prim.RotationOffset.Y; | ||
1576 | row["RotationZ"] = prim.RotationOffset.Z; | ||
1577 | row["RotationW"] = prim.RotationOffset.W; | ||
1578 | |||
1579 | // Sit target | ||
1580 | Vector3 sitTargetPos = prim.SitTargetPositionLL; | ||
1581 | row["SitTargetOffsetX"] = sitTargetPos.X; | ||
1582 | row["SitTargetOffsetY"] = sitTargetPos.Y; | ||
1583 | row["SitTargetOffsetZ"] = sitTargetPos.Z; | ||
1584 | |||
1585 | Quaternion sitTargetOrient = prim.SitTargetOrientationLL; | ||
1586 | row["SitTargetOrientW"] = sitTargetOrient.W; | ||
1587 | row["SitTargetOrientX"] = sitTargetOrient.X; | ||
1588 | row["SitTargetOrientY"] = sitTargetOrient.Y; | ||
1589 | row["SitTargetOrientZ"] = sitTargetOrient.Z; | ||
1590 | row["ColorR"] = Convert.ToInt32(prim.Color.R); | ||
1591 | row["ColorG"] = Convert.ToInt32(prim.Color.G); | ||
1592 | row["ColorB"] = Convert.ToInt32(prim.Color.B); | ||
1593 | row["ColorA"] = Convert.ToInt32(prim.Color.A); | ||
1594 | row["PayPrice"] = prim.PayPrice[0]; | ||
1595 | row["PayButton1"] = prim.PayPrice[1]; | ||
1596 | row["PayButton2"] = prim.PayPrice[2]; | ||
1597 | row["PayButton3"] = prim.PayPrice[3]; | ||
1598 | row["PayButton4"] = prim.PayPrice[4]; | ||
1599 | |||
1600 | |||
1601 | row["TextureAnimation"] = Convert.ToBase64String(prim.TextureAnimation); | ||
1602 | row["ParticleSystem"] = Convert.ToBase64String(prim.ParticleSystem); | ||
1603 | |||
1604 | row["OmegaX"] = prim.AngularVelocity.X; | ||
1605 | row["OmegaY"] = prim.AngularVelocity.Y; | ||
1606 | row["OmegaZ"] = prim.AngularVelocity.Z; | ||
1607 | |||
1608 | row["CameraEyeOffsetX"] = prim.GetCameraEyeOffset().X; | ||
1609 | row["CameraEyeOffsetY"] = prim.GetCameraEyeOffset().Y; | ||
1610 | row["CameraEyeOffsetZ"] = prim.GetCameraEyeOffset().Z; | ||
1611 | |||
1612 | row["CameraAtOffsetX"] = prim.GetCameraAtOffset().X; | ||
1613 | row["CameraAtOffsetY"] = prim.GetCameraAtOffset().Y; | ||
1614 | row["CameraAtOffsetZ"] = prim.GetCameraAtOffset().Z; | ||
1615 | |||
1616 | |||
1617 | if ((prim.SoundFlags & 1) != 0) // Looped | ||
1618 | { | ||
1619 | row["LoopedSound"] = prim.Sound.ToString(); | ||
1620 | row["LoopedSoundGain"] = prim.SoundGain; | ||
1621 | } | ||
1622 | else | ||
1623 | { | ||
1624 | row["LoopedSound"] = UUID.Zero.ToString(); | ||
1625 | row["LoopedSoundGain"] = 0.0f; | ||
1626 | } | ||
1627 | |||
1628 | if (prim.GetForceMouselook()) | ||
1629 | row["ForceMouselook"] = 1; | ||
1630 | else | ||
1631 | row["ForceMouselook"] = 0; | ||
1632 | |||
1633 | row["ScriptAccessPin"] = prim.ScriptAccessPin; | ||
1634 | |||
1635 | if (prim.AllowedDrop) | ||
1636 | row["AllowedDrop"] = 1; | ||
1637 | else | ||
1638 | row["AllowedDrop"] = 0; | ||
1639 | |||
1640 | if (prim.DIE_AT_EDGE) | ||
1641 | row["DieAtEdge"] = 1; | ||
1642 | else | ||
1643 | row["DieAtEdge"] = 0; | ||
1644 | |||
1645 | row["SalePrice"] = prim.SalePrice; | ||
1646 | row["SaleType"] = Convert.ToInt16(prim.ObjectSaleType); | ||
1647 | |||
1648 | // click action | ||
1649 | row["ClickAction"] = prim.ClickAction; | ||
1650 | |||
1651 | row["SalePrice"] = prim.SalePrice; | ||
1652 | row["Material"] = prim.Material; | ||
1653 | |||
1654 | row["CollisionSound"] = prim.CollisionSound.ToString(); | ||
1655 | row["CollisionSoundVolume"] = prim.CollisionSoundVolume; | ||
1656 | if (prim.VolumeDetectActive) | ||
1657 | row["VolumeDetect"] = 1; | ||
1658 | else | ||
1659 | row["VolumeDetect"] = 0; | ||
1660 | |||
1661 | } | ||
1662 | |||
1663 | /// <summary> | ||
1664 | /// | ||
1665 | /// </summary> | ||
1666 | /// <param name="row"></param> | ||
1667 | /// <param name="taskItem"></param> | ||
1668 | private static void fillItemRow(DataRow row, TaskInventoryItem taskItem) | ||
1669 | { | ||
1670 | row["itemID"] = taskItem.ItemID.ToString(); | ||
1671 | row["primID"] = taskItem.ParentPartID.ToString(); | ||
1672 | row["assetID"] = taskItem.AssetID.ToString(); | ||
1673 | row["parentFolderID"] = taskItem.ParentID.ToString(); | ||
1674 | |||
1675 | row["invType"] = taskItem.InvType; | ||
1676 | row["assetType"] = taskItem.Type; | ||
1677 | |||
1678 | row["name"] = taskItem.Name; | ||
1679 | row["description"] = taskItem.Description; | ||
1680 | row["creationDate"] = taskItem.CreationDate; | ||
1681 | row["creatorID"] = taskItem.CreatorID.ToString(); | ||
1682 | row["ownerID"] = taskItem.OwnerID.ToString(); | ||
1683 | row["lastOwnerID"] = taskItem.LastOwnerID.ToString(); | ||
1684 | row["groupID"] = taskItem.GroupID.ToString(); | ||
1685 | row["nextPermissions"] = taskItem.NextPermissions; | ||
1686 | row["currentPermissions"] = taskItem.CurrentPermissions; | ||
1687 | row["basePermissions"] = taskItem.BasePermissions; | ||
1688 | row["everyonePermissions"] = taskItem.EveryonePermissions; | ||
1689 | row["groupPermissions"] = taskItem.GroupPermissions; | ||
1690 | row["flags"] = taskItem.Flags; | ||
1691 | } | ||
1692 | |||
1693 | /// <summary> | ||
1694 | /// | ||
1695 | /// </summary> | ||
1696 | /// <param name="row"></param> | ||
1697 | /// <param name="land"></param> | ||
1698 | /// <param name="regionUUID"></param> | ||
1699 | private static void fillLandRow(DataRow row, LandData land, UUID regionUUID) | ||
1700 | { | ||
1701 | row["UUID"] = land.GlobalID.ToString(); | ||
1702 | row["RegionUUID"] = regionUUID.ToString(); | ||
1703 | row["LocalLandID"] = land.LocalID; | ||
1704 | |||
1705 | // Bitmap is a byte[512] | ||
1706 | row["Bitmap"] = land.Bitmap; | ||
1707 | |||
1708 | row["Name"] = land.Name; | ||
1709 | row["Desc"] = land.Description; | ||
1710 | row["OwnerUUID"] = land.OwnerID.ToString(); | ||
1711 | row["IsGroupOwned"] = land.IsGroupOwned; | ||
1712 | row["Area"] = land.Area; | ||
1713 | row["AuctionID"] = land.AuctionID; //Unemplemented | ||
1714 | row["Category"] = land.Category; //Enum OpenMetaverse.Parcel.ParcelCategory | ||
1715 | row["ClaimDate"] = land.ClaimDate; | ||
1716 | row["ClaimPrice"] = land.ClaimPrice; | ||
1717 | row["GroupUUID"] = land.GroupID.ToString(); | ||
1718 | row["SalePrice"] = land.SalePrice; | ||
1719 | row["LandStatus"] = land.Status; //Enum. OpenMetaverse.Parcel.ParcelStatus | ||
1720 | row["LandFlags"] = land.Flags; | ||
1721 | row["LandingType"] = land.LandingType; | ||
1722 | row["MediaAutoScale"] = land.MediaAutoScale; | ||
1723 | row["MediaTextureUUID"] = land.MediaID.ToString(); | ||
1724 | row["MediaURL"] = land.MediaURL; | ||
1725 | row["MusicURL"] = land.MusicURL; | ||
1726 | row["PassHours"] = land.PassHours; | ||
1727 | row["PassPrice"] = land.PassPrice; | ||
1728 | row["SnapshotUUID"] = land.SnapshotID.ToString(); | ||
1729 | row["UserLocationX"] = land.UserLocation.X; | ||
1730 | row["UserLocationY"] = land.UserLocation.Y; | ||
1731 | row["UserLocationZ"] = land.UserLocation.Z; | ||
1732 | row["UserLookAtX"] = land.UserLookAt.X; | ||
1733 | row["UserLookAtY"] = land.UserLookAt.Y; | ||
1734 | row["UserLookAtZ"] = land.UserLookAt.Z; | ||
1735 | row["AuthbuyerID"] = land.AuthBuyerID.ToString(); | ||
1736 | row["OtherCleanTime"] = land.OtherCleanTime; | ||
1737 | row["Dwell"] = land.Dwell; | ||
1738 | } | ||
1739 | |||
1740 | /// <summary> | ||
1741 | /// | ||
1742 | /// </summary> | ||
1743 | /// <param name="row"></param> | ||
1744 | /// <param name="entry"></param> | ||
1745 | /// <param name="parcelID"></param> | ||
1746 | private static void fillLandAccessRow(DataRow row, ParcelManager.ParcelAccessEntry entry, UUID parcelID) | ||
1747 | { | ||
1748 | row["LandUUID"] = parcelID.ToString(); | ||
1749 | row["AccessUUID"] = entry.AgentID.ToString(); | ||
1750 | row["Flags"] = entry.Flags; | ||
1751 | } | ||
1752 | |||
1753 | private static void fillRegionSettingsRow(DataRow row, RegionSettings settings) | ||
1754 | { | ||
1755 | row["regionUUID"] = settings.RegionUUID.ToString(); | ||
1756 | row["block_terraform"] = settings.BlockTerraform; | ||
1757 | row["block_fly"] = settings.BlockFly; | ||
1758 | row["allow_damage"] = settings.AllowDamage; | ||
1759 | row["restrict_pushing"] = settings.RestrictPushing; | ||
1760 | row["allow_land_resell"] = settings.AllowLandResell; | ||
1761 | row["allow_land_join_divide"] = settings.AllowLandJoinDivide; | ||
1762 | row["block_show_in_search"] = settings.BlockShowInSearch; | ||
1763 | row["agent_limit"] = settings.AgentLimit; | ||
1764 | row["object_bonus"] = settings.ObjectBonus; | ||
1765 | row["maturity"] = settings.Maturity; | ||
1766 | row["disable_scripts"] = settings.DisableScripts; | ||
1767 | row["disable_collisions"] = settings.DisableCollisions; | ||
1768 | row["disable_physics"] = settings.DisablePhysics; | ||
1769 | row["terrain_texture_1"] = settings.TerrainTexture1.ToString(); | ||
1770 | row["terrain_texture_2"] = settings.TerrainTexture2.ToString(); | ||
1771 | row["terrain_texture_3"] = settings.TerrainTexture3.ToString(); | ||
1772 | row["terrain_texture_4"] = settings.TerrainTexture4.ToString(); | ||
1773 | row["elevation_1_nw"] = settings.Elevation1NW; | ||
1774 | row["elevation_2_nw"] = settings.Elevation2NW; | ||
1775 | row["elevation_1_ne"] = settings.Elevation1NE; | ||
1776 | row["elevation_2_ne"] = settings.Elevation2NE; | ||
1777 | row["elevation_1_se"] = settings.Elevation1SE; | ||
1778 | row["elevation_2_se"] = settings.Elevation2SE; | ||
1779 | row["elevation_1_sw"] = settings.Elevation1SW; | ||
1780 | row["elevation_2_sw"] = settings.Elevation2SW; | ||
1781 | row["water_height"] = settings.WaterHeight; | ||
1782 | row["terrain_raise_limit"] = settings.TerrainRaiseLimit; | ||
1783 | row["terrain_lower_limit"] = settings.TerrainLowerLimit; | ||
1784 | row["use_estate_sun"] = settings.UseEstateSun; | ||
1785 | row["Sandbox"] = settings.Sandbox; // database uses upper case S for sandbox | ||
1786 | row["sunvectorx"] = settings.SunVector.X; | ||
1787 | row["sunvectory"] = settings.SunVector.Y; | ||
1788 | row["sunvectorz"] = settings.SunVector.Z; | ||
1789 | row["fixed_sun"] = settings.FixedSun; | ||
1790 | row["sun_position"] = settings.SunPosition; | ||
1791 | row["covenant"] = settings.Covenant.ToString(); | ||
1792 | } | ||
1793 | |||
1794 | /// <summary> | ||
1795 | /// | ||
1796 | /// </summary> | ||
1797 | /// <param name="row"></param> | ||
1798 | /// <returns></returns> | ||
1799 | private PrimitiveBaseShape buildShape(DataRow row) | ||
1800 | { | ||
1801 | PrimitiveBaseShape s = new PrimitiveBaseShape(); | ||
1802 | s.Scale = new Vector3( | ||
1803 | Convert.ToSingle(row["ScaleX"]), | ||
1804 | Convert.ToSingle(row["ScaleY"]), | ||
1805 | Convert.ToSingle(row["ScaleZ"]) | ||
1806 | ); | ||
1807 | // paths | ||
1808 | s.PCode = Convert.ToByte(row["PCode"]); | ||
1809 | s.PathBegin = Convert.ToUInt16(row["PathBegin"]); | ||
1810 | s.PathEnd = Convert.ToUInt16(row["PathEnd"]); | ||
1811 | s.PathScaleX = Convert.ToByte(row["PathScaleX"]); | ||
1812 | s.PathScaleY = Convert.ToByte(row["PathScaleY"]); | ||
1813 | s.PathShearX = Convert.ToByte(row["PathShearX"]); | ||
1814 | s.PathShearY = Convert.ToByte(row["PathShearY"]); | ||
1815 | s.PathSkew = Convert.ToSByte(row["PathSkew"]); | ||
1816 | s.PathCurve = Convert.ToByte(row["PathCurve"]); | ||
1817 | s.PathRadiusOffset = Convert.ToSByte(row["PathRadiusOffset"]); | ||
1818 | s.PathRevolutions = Convert.ToByte(row["PathRevolutions"]); | ||
1819 | s.PathTaperX = Convert.ToSByte(row["PathTaperX"]); | ||
1820 | s.PathTaperY = Convert.ToSByte(row["PathTaperY"]); | ||
1821 | s.PathTwist = Convert.ToSByte(row["PathTwist"]); | ||
1822 | s.PathTwistBegin = Convert.ToSByte(row["PathTwistBegin"]); | ||
1823 | // profile | ||
1824 | s.ProfileBegin = Convert.ToUInt16(row["ProfileBegin"]); | ||
1825 | s.ProfileEnd = Convert.ToUInt16(row["ProfileEnd"]); | ||
1826 | s.ProfileCurve = Convert.ToByte(row["ProfileCurve"]); | ||
1827 | s.ProfileHollow = Convert.ToUInt16(row["ProfileHollow"]); | ||
1828 | s.State = Convert.ToByte(row["State"]); | ||
1829 | |||
1830 | byte[] textureEntry = (byte[])row["Texture"]; | ||
1831 | s.TextureEntry = textureEntry; | ||
1832 | |||
1833 | s.ExtraParams = (byte[]) row["ExtraParams"]; | ||
1834 | return s; | ||
1835 | } | ||
1836 | |||
1837 | /// <summary> | ||
1838 | /// | ||
1839 | /// </summary> | ||
1840 | /// <param name="row"></param> | ||
1841 | /// <param name="prim"></param> | ||
1842 | private static void fillShapeRow(DataRow row, SceneObjectPart prim) | ||
1843 | { | ||
1844 | PrimitiveBaseShape s = prim.Shape; | ||
1845 | row["UUID"] = prim.UUID.ToString(); | ||
1846 | // shape is an enum | ||
1847 | row["Shape"] = 0; | ||
1848 | // vectors | ||
1849 | row["ScaleX"] = s.Scale.X; | ||
1850 | row["ScaleY"] = s.Scale.Y; | ||
1851 | row["ScaleZ"] = s.Scale.Z; | ||
1852 | // paths | ||
1853 | row["PCode"] = s.PCode; | ||
1854 | row["PathBegin"] = s.PathBegin; | ||
1855 | row["PathEnd"] = s.PathEnd; | ||
1856 | row["PathScaleX"] = s.PathScaleX; | ||
1857 | row["PathScaleY"] = s.PathScaleY; | ||
1858 | row["PathShearX"] = s.PathShearX; | ||
1859 | row["PathShearY"] = s.PathShearY; | ||
1860 | row["PathSkew"] = s.PathSkew; | ||
1861 | row["PathCurve"] = s.PathCurve; | ||
1862 | row["PathRadiusOffset"] = s.PathRadiusOffset; | ||
1863 | row["PathRevolutions"] = s.PathRevolutions; | ||
1864 | row["PathTaperX"] = s.PathTaperX; | ||
1865 | row["PathTaperY"] = s.PathTaperY; | ||
1866 | row["PathTwist"] = s.PathTwist; | ||
1867 | row["PathTwistBegin"] = s.PathTwistBegin; | ||
1868 | // profile | ||
1869 | row["ProfileBegin"] = s.ProfileBegin; | ||
1870 | row["ProfileEnd"] = s.ProfileEnd; | ||
1871 | row["ProfileCurve"] = s.ProfileCurve; | ||
1872 | row["ProfileHollow"] = s.ProfileHollow; | ||
1873 | row["State"] = s.State; | ||
1874 | |||
1875 | row["Texture"] = s.TextureEntry; | ||
1876 | row["ExtraParams"] = s.ExtraParams; | ||
1877 | } | ||
1878 | |||
1879 | /// <summary> | ||
1880 | /// | ||
1881 | /// </summary> | ||
1882 | /// <param name="prim"></param> | ||
1883 | /// <param name="sceneGroupID"></param> | ||
1884 | /// <param name="regionUUID"></param> | ||
1885 | private void addPrim(SceneObjectPart prim, UUID sceneGroupID, UUID regionUUID) | ||
1886 | { | ||
1887 | |||
1888 | DataTable prims = ds.Tables["prims"]; | ||
1889 | DataTable shapes = ds.Tables["primshapes"]; | ||
1890 | |||
1891 | DataRow primRow = prims.Rows.Find(prim.UUID.ToString()); | ||
1892 | if (primRow == null) | ||
1893 | { | ||
1894 | primRow = prims.NewRow(); | ||
1895 | fillPrimRow(primRow, prim, sceneGroupID, regionUUID); | ||
1896 | prims.Rows.Add(primRow); | ||
1897 | } | ||
1898 | else | ||
1899 | { | ||
1900 | fillPrimRow(primRow, prim, sceneGroupID, regionUUID); | ||
1901 | } | ||
1902 | |||
1903 | DataRow shapeRow = shapes.Rows.Find(prim.UUID.ToString()); | ||
1904 | if (shapeRow == null) | ||
1905 | { | ||
1906 | shapeRow = shapes.NewRow(); | ||
1907 | fillShapeRow(shapeRow, prim); | ||
1908 | shapes.Rows.Add(shapeRow); | ||
1909 | } | ||
1910 | else | ||
1911 | { | ||
1912 | fillShapeRow(shapeRow, prim); | ||
1913 | } | ||
1914 | } | ||
1915 | |||
1916 | /// <summary> | ||
1917 | /// see IRegionDatastore | ||
1918 | /// </summary> | ||
1919 | /// <param name="primID"></param> | ||
1920 | /// <param name="items"></param> | ||
1921 | public void StorePrimInventory(UUID primID, ICollection<TaskInventoryItem> items) | ||
1922 | { | ||
1923 | m_log.InfoFormat("[REGION DB]: Entered StorePrimInventory with prim ID {0}", primID); | ||
1924 | |||
1925 | DataTable dbItems = ds.Tables["primitems"]; | ||
1926 | |||
1927 | // For now, we're just going to crudely remove all the previous inventory items | ||
1928 | // no matter whether they have changed or not, and replace them with the current set. | ||
1929 | lock (ds) | ||
1930 | { | ||
1931 | RemoveItems(primID); | ||
1932 | |||
1933 | // repalce with current inventory details | ||
1934 | foreach (TaskInventoryItem newItem in items) | ||
1935 | { | ||
1936 | // m_log.InfoFormat( | ||
1937 | // "[DATASTORE]: ", | ||
1938 | // "Adding item {0}, {1} to prim ID {2}", | ||
1939 | // newItem.Name, newItem.ItemID, newItem.ParentPartID); | ||
1940 | |||
1941 | DataRow newItemRow = dbItems.NewRow(); | ||
1942 | fillItemRow(newItemRow, newItem); | ||
1943 | dbItems.Rows.Add(newItemRow); | ||
1944 | } | ||
1945 | } | ||
1946 | |||
1947 | Commit(); | ||
1948 | } | ||
1949 | |||
1950 | /*********************************************************************** | ||
1951 | * | ||
1952 | * SQL Statement Creation Functions | ||
1953 | * | ||
1954 | * These functions create SQL statements for update, insert, and create. | ||
1955 | * They can probably be factored later to have a db independant | ||
1956 | * portion and a db specific portion | ||
1957 | * | ||
1958 | **********************************************************************/ | ||
1959 | |||
1960 | /// <summary> | ||
1961 | /// Create an insert command | ||
1962 | /// </summary> | ||
1963 | /// <param name="table">table name</param> | ||
1964 | /// <param name="dt">data table</param> | ||
1965 | /// <returns>the created command</returns> | ||
1966 | /// <remarks> | ||
1967 | /// This is subtle enough to deserve some commentary. | ||
1968 | /// Instead of doing *lots* and *lots of hardcoded strings | ||
1969 | /// for database definitions we'll use the fact that | ||
1970 | /// realistically all insert statements look like "insert | ||
1971 | /// into A(b, c) values(:b, :c) on the parameterized query | ||
1972 | /// front. If we just have a list of b, c, etc... we can | ||
1973 | /// generate these strings instead of typing them out. | ||
1974 | /// </remarks> | ||
1975 | private static SqliteCommand createInsertCommand(string table, DataTable dt) | ||
1976 | { | ||
1977 | string[] cols = new string[dt.Columns.Count]; | ||
1978 | for (int i = 0; i < dt.Columns.Count; i++) | ||
1979 | { | ||
1980 | DataColumn col = dt.Columns[i]; | ||
1981 | cols[i] = col.ColumnName; | ||
1982 | } | ||
1983 | |||
1984 | string sql = "insert into " + table + "("; | ||
1985 | sql += String.Join(", ", cols); | ||
1986 | // important, the first ':' needs to be here, the rest get added in the join | ||
1987 | sql += ") values (:"; | ||
1988 | sql += String.Join(", :", cols); | ||
1989 | sql += ")"; | ||
1990 | m_log.DebugFormat("[SQLITE]: Created insert command {0}", sql); | ||
1991 | SqliteCommand cmd = new SqliteCommand(sql); | ||
1992 | |||
1993 | // this provides the binding for all our parameters, so | ||
1994 | // much less code than it used to be | ||
1995 | foreach (DataColumn col in dt.Columns) | ||
1996 | { | ||
1997 | cmd.Parameters.Add(createSqliteParameter(col.ColumnName, col.DataType)); | ||
1998 | } | ||
1999 | return cmd; | ||
2000 | } | ||
2001 | |||
2002 | |||
2003 | /// <summary> | ||
2004 | /// create an update command | ||
2005 | /// </summary> | ||
2006 | /// <param name="table">table name</param> | ||
2007 | /// <param name="pk"></param> | ||
2008 | /// <param name="dt"></param> | ||
2009 | /// <returns>the created command</returns> | ||
2010 | private static SqliteCommand createUpdateCommand(string table, string pk, DataTable dt) | ||
2011 | { | ||
2012 | string sql = "update " + table + " set "; | ||
2013 | string subsql = String.Empty; | ||
2014 | foreach (DataColumn col in dt.Columns) | ||
2015 | { | ||
2016 | if (subsql.Length > 0) | ||
2017 | { | ||
2018 | // a map function would rock so much here | ||
2019 | subsql += ", "; | ||
2020 | } | ||
2021 | subsql += col.ColumnName + "= :" + col.ColumnName; | ||
2022 | } | ||
2023 | sql += subsql; | ||
2024 | sql += " where " + pk; | ||
2025 | SqliteCommand cmd = new SqliteCommand(sql); | ||
2026 | |||
2027 | // this provides the binding for all our parameters, so | ||
2028 | // much less code than it used to be | ||
2029 | |||
2030 | foreach (DataColumn col in dt.Columns) | ||
2031 | { | ||
2032 | cmd.Parameters.Add(createSqliteParameter(col.ColumnName, col.DataType)); | ||
2033 | } | ||
2034 | return cmd; | ||
2035 | } | ||
2036 | |||
2037 | /// <summary> | ||
2038 | /// create an update command | ||
2039 | /// </summary> | ||
2040 | /// <param name="table">table name</param> | ||
2041 | /// <param name="pk"></param> | ||
2042 | /// <param name="dt"></param> | ||
2043 | /// <returns>the created command</returns> | ||
2044 | private static SqliteCommand createUpdateCommand(string table, string pk1, string pk2, DataTable dt) | ||
2045 | { | ||
2046 | string sql = "update " + table + " set "; | ||
2047 | string subsql = String.Empty; | ||
2048 | foreach (DataColumn col in dt.Columns) | ||
2049 | { | ||
2050 | if (subsql.Length > 0) | ||
2051 | { | ||
2052 | // a map function would rock so much here | ||
2053 | subsql += ", "; | ||
2054 | } | ||
2055 | subsql += col.ColumnName + "= :" + col.ColumnName; | ||
2056 | } | ||
2057 | sql += subsql; | ||
2058 | sql += " where " + pk1 + " and " + pk2; | ||
2059 | SqliteCommand cmd = new SqliteCommand(sql); | ||
2060 | |||
2061 | // this provides the binding for all our parameters, so | ||
2062 | // much less code than it used to be | ||
2063 | |||
2064 | foreach (DataColumn col in dt.Columns) | ||
2065 | { | ||
2066 | cmd.Parameters.Add(createSqliteParameter(col.ColumnName, col.DataType)); | ||
2067 | } | ||
2068 | return cmd; | ||
2069 | } | ||
2070 | |||
2071 | /// <summary> | ||
2072 | /// | ||
2073 | /// </summary> | ||
2074 | /// <param name="dt">Data Table</param> | ||
2075 | /// <returns></returns> | ||
2076 | // private static string defineTable(DataTable dt) | ||
2077 | // { | ||
2078 | // string sql = "create table " + dt.TableName + "("; | ||
2079 | // string subsql = String.Empty; | ||
2080 | // foreach (DataColumn col in dt.Columns) | ||
2081 | // { | ||
2082 | // if (subsql.Length > 0) | ||
2083 | // { | ||
2084 | // // a map function would rock so much here | ||
2085 | // subsql += ",\n"; | ||
2086 | // } | ||
2087 | // subsql += col.ColumnName + " " + sqliteType(col.DataType); | ||
2088 | // if (dt.PrimaryKey.Length > 0 && col == dt.PrimaryKey[0]) | ||
2089 | // { | ||
2090 | // subsql += " primary key"; | ||
2091 | // } | ||
2092 | // } | ||
2093 | // sql += subsql; | ||
2094 | // sql += ")"; | ||
2095 | // return sql; | ||
2096 | // } | ||
2097 | |||
2098 | /*********************************************************************** | ||
2099 | * | ||
2100 | * Database Binding functions | ||
2101 | * | ||
2102 | * These will be db specific due to typing, and minor differences | ||
2103 | * in databases. | ||
2104 | * | ||
2105 | **********************************************************************/ | ||
2106 | |||
2107 | ///<summary> | ||
2108 | /// This is a convenience function that collapses 5 repetitive | ||
2109 | /// lines for defining SqliteParameters to 2 parameters: | ||
2110 | /// column name and database type. | ||
2111 | /// | ||
2112 | /// It assumes certain conventions like :param as the param | ||
2113 | /// name to replace in parametrized queries, and that source | ||
2114 | /// version is always current version, both of which are fine | ||
2115 | /// for us. | ||
2116 | ///</summary> | ||
2117 | ///<returns>a built sqlite parameter</returns> | ||
2118 | private static SqliteParameter createSqliteParameter(string name, Type type) | ||
2119 | { | ||
2120 | SqliteParameter param = new SqliteParameter(); | ||
2121 | param.ParameterName = ":" + name; | ||
2122 | param.DbType = dbtypeFromType(type); | ||
2123 | param.SourceColumn = name; | ||
2124 | param.SourceVersion = DataRowVersion.Current; | ||
2125 | return param; | ||
2126 | } | ||
2127 | |||
2128 | /// <summary> | ||
2129 | /// | ||
2130 | /// </summary> | ||
2131 | /// <param name="da"></param> | ||
2132 | /// <param name="conn"></param> | ||
2133 | private void setupPrimCommands(SqliteDataAdapter da, SqliteConnection conn) | ||
2134 | { | ||
2135 | da.InsertCommand = createInsertCommand("prims", ds.Tables["prims"]); | ||
2136 | da.InsertCommand.Connection = conn; | ||
2137 | |||
2138 | da.UpdateCommand = createUpdateCommand("prims", "UUID=:UUID", ds.Tables["prims"]); | ||
2139 | da.UpdateCommand.Connection = conn; | ||
2140 | |||
2141 | SqliteCommand delete = new SqliteCommand("delete from prims where UUID = :UUID"); | ||
2142 | delete.Parameters.Add(createSqliteParameter("UUID", typeof (String))); | ||
2143 | delete.Connection = conn; | ||
2144 | da.DeleteCommand = delete; | ||
2145 | } | ||
2146 | |||
2147 | /// <summary> | ||
2148 | /// | ||
2149 | /// </summary> | ||
2150 | /// <param name="da"></param> | ||
2151 | /// <param name="conn"></param> | ||
2152 | private void setupItemsCommands(SqliteDataAdapter da, SqliteConnection conn) | ||
2153 | { | ||
2154 | da.InsertCommand = createInsertCommand("primitems", ds.Tables["primitems"]); | ||
2155 | da.InsertCommand.Connection = conn; | ||
2156 | |||
2157 | da.UpdateCommand = createUpdateCommand("primitems", "itemID = :itemID", ds.Tables["primitems"]); | ||
2158 | da.UpdateCommand.Connection = conn; | ||
2159 | |||
2160 | SqliteCommand delete = new SqliteCommand("delete from primitems where itemID = :itemID"); | ||
2161 | delete.Parameters.Add(createSqliteParameter("itemID", typeof (String))); | ||
2162 | delete.Connection = conn; | ||
2163 | da.DeleteCommand = delete; | ||
2164 | } | ||
2165 | |||
2166 | /// <summary> | ||
2167 | /// | ||
2168 | /// </summary> | ||
2169 | /// <param name="da"></param> | ||
2170 | /// <param name="conn"></param> | ||
2171 | private void setupTerrainCommands(SqliteDataAdapter da, SqliteConnection conn) | ||
2172 | { | ||
2173 | da.InsertCommand = createInsertCommand("terrain", ds.Tables["terrain"]); | ||
2174 | da.InsertCommand.Connection = conn; | ||
2175 | } | ||
2176 | |||
2177 | /// <summary> | ||
2178 | /// | ||
2179 | /// </summary> | ||
2180 | /// <param name="da"></param> | ||
2181 | /// <param name="conn"></param> | ||
2182 | private void setupLandCommands(SqliteDataAdapter da, SqliteConnection conn) | ||
2183 | { | ||
2184 | da.InsertCommand = createInsertCommand("land", ds.Tables["land"]); | ||
2185 | da.InsertCommand.Connection = conn; | ||
2186 | |||
2187 | da.UpdateCommand = createUpdateCommand("land", "UUID=:UUID", ds.Tables["land"]); | ||
2188 | da.UpdateCommand.Connection = conn; | ||
2189 | |||
2190 | SqliteCommand delete = new SqliteCommand("delete from land where UUID=:UUID"); | ||
2191 | delete.Parameters.Add(createSqliteParameter("UUID", typeof(String))); | ||
2192 | da.DeleteCommand = delete; | ||
2193 | da.DeleteCommand.Connection = conn; | ||
2194 | } | ||
2195 | |||
2196 | /// <summary> | ||
2197 | /// | ||
2198 | /// </summary> | ||
2199 | /// <param name="da"></param> | ||
2200 | /// <param name="conn"></param> | ||
2201 | private void setupLandAccessCommands(SqliteDataAdapter da, SqliteConnection conn) | ||
2202 | { | ||
2203 | da.InsertCommand = createInsertCommand("landaccesslist", ds.Tables["landaccesslist"]); | ||
2204 | da.InsertCommand.Connection = conn; | ||
2205 | |||
2206 | da.UpdateCommand = createUpdateCommand("landaccesslist", "LandUUID=:landUUID", "AccessUUID=:AccessUUID", ds.Tables["landaccesslist"]); | ||
2207 | da.UpdateCommand.Connection = conn; | ||
2208 | |||
2209 | SqliteCommand delete = new SqliteCommand("delete from landaccesslist where LandUUID= :LandUUID and AccessUUID= :AccessUUID"); | ||
2210 | delete.Parameters.Add(createSqliteParameter("LandUUID", typeof(String))); | ||
2211 | delete.Parameters.Add(createSqliteParameter("AccessUUID", typeof(String))); | ||
2212 | da.DeleteCommand = delete; | ||
2213 | da.DeleteCommand.Connection = conn; | ||
2214 | |||
2215 | } | ||
2216 | |||
2217 | private void setupRegionSettingsCommands(SqliteDataAdapter da, SqliteConnection conn) | ||
2218 | { | ||
2219 | da.InsertCommand = createInsertCommand("regionsettings", ds.Tables["regionsettings"]); | ||
2220 | da.InsertCommand.Connection = conn; | ||
2221 | da.UpdateCommand = createUpdateCommand("regionsettings", "regionUUID=:regionUUID", ds.Tables["regionsettings"]); | ||
2222 | da.UpdateCommand.Connection = conn; | ||
2223 | } | ||
2224 | |||
2225 | /// <summary> | ||
2226 | /// | ||
2227 | /// </summary> | ||
2228 | /// <param name="da"></param> | ||
2229 | /// <param name="conn"></param> | ||
2230 | private void setupShapeCommands(SqliteDataAdapter da, SqliteConnection conn) | ||
2231 | { | ||
2232 | da.InsertCommand = createInsertCommand("primshapes", ds.Tables["primshapes"]); | ||
2233 | da.InsertCommand.Connection = conn; | ||
2234 | |||
2235 | da.UpdateCommand = createUpdateCommand("primshapes", "UUID=:UUID", ds.Tables["primshapes"]); | ||
2236 | da.UpdateCommand.Connection = conn; | ||
2237 | |||
2238 | SqliteCommand delete = new SqliteCommand("delete from primshapes where UUID = :UUID"); | ||
2239 | delete.Parameters.Add(createSqliteParameter("UUID", typeof (String))); | ||
2240 | delete.Connection = conn; | ||
2241 | da.DeleteCommand = delete; | ||
2242 | } | ||
2243 | |||
2244 | /*********************************************************************** | ||
2245 | * | ||
2246 | * Type conversion functions | ||
2247 | * | ||
2248 | **********************************************************************/ | ||
2249 | |||
2250 | /// <summary> | ||
2251 | /// Type conversion function | ||
2252 | /// </summary> | ||
2253 | /// <param name="type"></param> | ||
2254 | /// <returns></returns> | ||
2255 | private static DbType dbtypeFromType(Type type) | ||
2256 | { | ||
2257 | if (type == typeof (String)) | ||
2258 | { | ||
2259 | return DbType.String; | ||
2260 | } | ||
2261 | else if (type == typeof (Int32)) | ||
2262 | { | ||
2263 | return DbType.Int32; | ||
2264 | } | ||
2265 | else if (type == typeof (Double)) | ||
2266 | { | ||
2267 | return DbType.Double; | ||
2268 | } | ||
2269 | else if (type == typeof (Byte)) | ||
2270 | { | ||
2271 | return DbType.Byte; | ||
2272 | } | ||
2273 | else if (type == typeof (Double)) | ||
2274 | { | ||
2275 | return DbType.Double; | ||
2276 | } | ||
2277 | else if (type == typeof (Byte[])) | ||
2278 | { | ||
2279 | return DbType.Binary; | ||
2280 | } | ||
2281 | else | ||
2282 | { | ||
2283 | return DbType.String; | ||
2284 | } | ||
2285 | } | ||
2286 | |||
2287 | static void PrintDataSet(DataSet ds) | ||
2288 | { | ||
2289 | // Print out any name and extended properties. | ||
2290 | Console.WriteLine("DataSet is named: {0}", ds.DataSetName); | ||
2291 | foreach (System.Collections.DictionaryEntry de in ds.ExtendedProperties) | ||
2292 | { | ||
2293 | Console.WriteLine("Key = {0}, Value = {1}", de.Key, de.Value); | ||
2294 | } | ||
2295 | Console.WriteLine(); | ||
2296 | foreach (DataTable dt in ds.Tables) | ||
2297 | { | ||
2298 | Console.WriteLine("=> {0} Table:", dt.TableName); | ||
2299 | // Print out the column names. | ||
2300 | for (int curCol = 0; curCol < dt.Columns.Count; curCol++) | ||
2301 | { | ||
2302 | Console.Write(dt.Columns[curCol].ColumnName + "\t"); | ||
2303 | } | ||
2304 | Console.WriteLine("\n----------------------------------"); | ||
2305 | // Print the DataTable. | ||
2306 | for (int curRow = 0; curRow < dt.Rows.Count; curRow++) | ||
2307 | { | ||
2308 | for (int curCol = 0; curCol < dt.Columns.Count; curCol++) | ||
2309 | { | ||
2310 | Console.Write(dt.Rows[curRow][curCol].ToString() + "\t"); | ||
2311 | } | ||
2312 | Console.WriteLine(); | ||
2313 | } | ||
2314 | } | ||
2315 | } | ||
2316 | |||
2317 | } | ||
2318 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteUserAccountData.cs b/OpenSim/Data/SQLiteNG/SQLiteUserAccountData.cs new file mode 100644 index 0000000..893f105 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteUserAccountData.cs | |||
@@ -0,0 +1,81 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Collections; | ||
30 | using System.Collections.Generic; | ||
31 | using System.Data; | ||
32 | using OpenMetaverse; | ||
33 | using OpenSim.Framework; | ||
34 | using Mono.Data.Sqlite; | ||
35 | |||
36 | namespace OpenSim.Data.SQLite | ||
37 | { | ||
38 | public class SQLiteUserAccountData : SQLiteGenericTableHandler<UserAccountData>, IUserAccountData | ||
39 | { | ||
40 | public SQLiteUserAccountData(string connectionString, string realm) | ||
41 | : base(connectionString, realm, "UserAccount") | ||
42 | { | ||
43 | } | ||
44 | |||
45 | public UserAccountData[] GetUsers(UUID scopeID, string query) | ||
46 | { | ||
47 | string[] words = query.Split(new char[] {' '}); | ||
48 | |||
49 | for (int i = 0 ; i < words.Length ; i++) | ||
50 | { | ||
51 | if (words[i].Length < 3) | ||
52 | { | ||
53 | if (i != words.Length - 1) | ||
54 | Array.Copy(words, i + 1, words, i, words.Length - i - 1); | ||
55 | Array.Resize(ref words, words.Length - 1); | ||
56 | } | ||
57 | } | ||
58 | |||
59 | if (words.Length == 0) | ||
60 | return new UserAccountData[0]; | ||
61 | |||
62 | if (words.Length > 2) | ||
63 | return new UserAccountData[0]; | ||
64 | |||
65 | SqliteCommand cmd = new SqliteCommand(); | ||
66 | |||
67 | if (words.Length == 1) | ||
68 | { | ||
69 | cmd.CommandText = String.Format("select * from {0} where ScopeID='{1}' or ScopeID='00000000-0000-0000-0000-000000000000') and (FirstName like '{2}%' or LastName like '{2}%')", | ||
70 | m_Realm, scopeID.ToString(), words[0]); | ||
71 | } | ||
72 | else | ||
73 | { | ||
74 | cmd.CommandText = String.Format("select * from {0} where (ScopeID='{1}' or ScopeID='00000000-0000-0000-0000-000000000000') and (FirstName like '{2}%' or LastName like '{3}%')", | ||
75 | m_Realm, scopeID.ToString(), words[0], words[1]); | ||
76 | } | ||
77 | |||
78 | return DoQuery(cmd); | ||
79 | } | ||
80 | } | ||
81 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteUtils.cs b/OpenSim/Data/SQLiteNG/SQLiteUtils.cs new file mode 100644 index 0000000..07c6b69 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteUtils.cs | |||
@@ -0,0 +1,307 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Data; | ||
30 | using Mono.Data.Sqlite; | ||
31 | |||
32 | namespace OpenSim.Data.SQLite | ||
33 | { | ||
34 | /// <summary> | ||
35 | /// A base class for methods needed by all SQLite database classes | ||
36 | /// </summary> | ||
37 | public class SQLiteUtil | ||
38 | { | ||
39 | /*********************************************************************** | ||
40 | * | ||
41 | * Database Definition Helper Functions | ||
42 | * | ||
43 | * This should be db agnostic as we define them in ADO.NET terms | ||
44 | * | ||
45 | **********************************************************************/ | ||
46 | |||
47 | /// <summary> | ||
48 | /// | ||
49 | /// </summary> | ||
50 | /// <param name="dt"></param> | ||
51 | /// <param name="name"></param> | ||
52 | /// <param name="type"></param> | ||
53 | public static void createCol(DataTable dt, string name, Type type) | ||
54 | { | ||
55 | DataColumn col = new DataColumn(name, type); | ||
56 | dt.Columns.Add(col); | ||
57 | } | ||
58 | |||
59 | /*********************************************************************** | ||
60 | * | ||
61 | * SQL Statement Creation Functions | ||
62 | * | ||
63 | * These functions create SQL statements for update, insert, and create. | ||
64 | * They can probably be factored later to have a db independant | ||
65 | * portion and a db specific portion | ||
66 | * | ||
67 | **********************************************************************/ | ||
68 | |||
69 | /// <summary> | ||
70 | /// Create an insert command | ||
71 | /// </summary> | ||
72 | /// <param name="table">table name</param> | ||
73 | /// <param name="dt">data table</param> | ||
74 | /// <returns>the created command</returns> | ||
75 | /// <remarks> | ||
76 | /// This is subtle enough to deserve some commentary. | ||
77 | /// Instead of doing *lots* and *lots of hardcoded strings | ||
78 | /// for database definitions we'll use the fact that | ||
79 | /// realistically all insert statements look like "insert | ||
80 | /// into A(b, c) values(:b, :c) on the parameterized query | ||
81 | /// front. If we just have a list of b, c, etc... we can | ||
82 | /// generate these strings instead of typing them out. | ||
83 | /// </remarks> | ||
84 | public static SqliteCommand createInsertCommand(string table, DataTable dt) | ||
85 | { | ||
86 | |||
87 | string[] cols = new string[dt.Columns.Count]; | ||
88 | for (int i = 0; i < dt.Columns.Count; i++) | ||
89 | { | ||
90 | DataColumn col = dt.Columns[i]; | ||
91 | cols[i] = col.ColumnName; | ||
92 | } | ||
93 | |||
94 | string sql = "insert into " + table + "("; | ||
95 | sql += String.Join(", ", cols); | ||
96 | // important, the first ':' needs to be here, the rest get added in the join | ||
97 | sql += ") values (:"; | ||
98 | sql += String.Join(", :", cols); | ||
99 | sql += ")"; | ||
100 | SqliteCommand cmd = new SqliteCommand(sql); | ||
101 | |||
102 | // this provides the binding for all our parameters, so | ||
103 | // much less code than it used to be | ||
104 | foreach (DataColumn col in dt.Columns) | ||
105 | { | ||
106 | cmd.Parameters.Add(createSqliteParameter(col.ColumnName, col.DataType)); | ||
107 | } | ||
108 | return cmd; | ||
109 | } | ||
110 | |||
111 | /// <summary> | ||
112 | /// create an update command | ||
113 | /// </summary> | ||
114 | /// <param name="table">table name</param> | ||
115 | /// <param name="pk"></param> | ||
116 | /// <param name="dt"></param> | ||
117 | /// <returns>the created command</returns> | ||
118 | public static SqliteCommand createUpdateCommand(string table, string pk, DataTable dt) | ||
119 | { | ||
120 | string sql = "update " + table + " set "; | ||
121 | string subsql = String.Empty; | ||
122 | foreach (DataColumn col in dt.Columns) | ||
123 | { | ||
124 | if (subsql.Length > 0) | ||
125 | { | ||
126 | // a map function would rock so much here | ||
127 | subsql += ", "; | ||
128 | } | ||
129 | subsql += col.ColumnName + "= :" + col.ColumnName; | ||
130 | } | ||
131 | sql += subsql; | ||
132 | sql += " where " + pk; | ||
133 | SqliteCommand cmd = new SqliteCommand(sql); | ||
134 | |||
135 | // this provides the binding for all our parameters, so | ||
136 | // much less code than it used to be | ||
137 | |||
138 | foreach (DataColumn col in dt.Columns) | ||
139 | { | ||
140 | cmd.Parameters.Add(createSqliteParameter(col.ColumnName, col.DataType)); | ||
141 | } | ||
142 | return cmd; | ||
143 | } | ||
144 | |||
145 | /// <summary> | ||
146 | /// | ||
147 | /// </summary> | ||
148 | /// <param name="dt">Data Table</param> | ||
149 | /// <returns></returns> | ||
150 | public static string defineTable(DataTable dt) | ||
151 | { | ||
152 | string sql = "create table " + dt.TableName + "("; | ||
153 | string subsql = String.Empty; | ||
154 | foreach (DataColumn col in dt.Columns) | ||
155 | { | ||
156 | if (subsql.Length > 0) | ||
157 | { | ||
158 | // a map function would rock so much here | ||
159 | subsql += ",\n"; | ||
160 | } | ||
161 | subsql += col.ColumnName + " " + sqliteType(col.DataType); | ||
162 | if (dt.PrimaryKey.Length > 0) | ||
163 | { | ||
164 | if (col == dt.PrimaryKey[0]) | ||
165 | { | ||
166 | subsql += " primary key"; | ||
167 | } | ||
168 | } | ||
169 | } | ||
170 | sql += subsql; | ||
171 | sql += ")"; | ||
172 | return sql; | ||
173 | } | ||
174 | |||
175 | /*********************************************************************** | ||
176 | * | ||
177 | * Database Binding functions | ||
178 | * | ||
179 | * These will be db specific due to typing, and minor differences | ||
180 | * in databases. | ||
181 | * | ||
182 | **********************************************************************/ | ||
183 | |||
184 | ///<summary> | ||
185 | /// <para> | ||
186 | /// This is a convenience function that collapses 5 repetitive | ||
187 | /// lines for defining SqliteParameters to 2 parameters: | ||
188 | /// column name and database type. | ||
189 | /// </para> | ||
190 | /// | ||
191 | /// <para> | ||
192 | /// It assumes certain conventions like :param as the param | ||
193 | /// name to replace in parametrized queries, and that source | ||
194 | /// version is always current version, both of which are fine | ||
195 | /// for us. | ||
196 | /// </para> | ||
197 | ///</summary> | ||
198 | /// <param name="name"></param> | ||
199 | /// <param name="type"></param> | ||
200 | ///<returns>a built sqlite parameter</returns> | ||
201 | public static SqliteParameter createSqliteParameter(string name, Type type) | ||
202 | { | ||
203 | SqliteParameter param = new SqliteParameter(); | ||
204 | param.ParameterName = ":" + name; | ||
205 | param.DbType = dbtypeFromType(type); | ||
206 | param.SourceColumn = name; | ||
207 | param.SourceVersion = DataRowVersion.Current; | ||
208 | return param; | ||
209 | } | ||
210 | |||
211 | /*********************************************************************** | ||
212 | * | ||
213 | * Type conversion functions | ||
214 | * | ||
215 | **********************************************************************/ | ||
216 | |||
217 | /// <summary> | ||
218 | /// Type conversion function | ||
219 | /// </summary> | ||
220 | /// <param name="type">a type</param> | ||
221 | /// <returns>a DbType</returns> | ||
222 | public static DbType dbtypeFromType(Type type) | ||
223 | { | ||
224 | if (type == typeof (String)) | ||
225 | { | ||
226 | return DbType.String; | ||
227 | } | ||
228 | else if (type == typeof (Int32)) | ||
229 | { | ||
230 | return DbType.Int32; | ||
231 | } | ||
232 | else if (type == typeof (UInt32)) | ||
233 | { | ||
234 | return DbType.UInt32; | ||
235 | } | ||
236 | else if (type == typeof (Int64)) | ||
237 | { | ||
238 | return DbType.Int64; | ||
239 | } | ||
240 | else if (type == typeof (UInt64)) | ||
241 | { | ||
242 | return DbType.UInt64; | ||
243 | } | ||
244 | else if (type == typeof (Double)) | ||
245 | { | ||
246 | return DbType.Double; | ||
247 | } | ||
248 | else if (type == typeof (Boolean)) | ||
249 | { | ||
250 | return DbType.Boolean; | ||
251 | } | ||
252 | else if (type == typeof (Byte[])) | ||
253 | { | ||
254 | return DbType.Binary; | ||
255 | } | ||
256 | else | ||
257 | { | ||
258 | return DbType.String; | ||
259 | } | ||
260 | } | ||
261 | |||
262 | /// <summary> | ||
263 | /// </summary> | ||
264 | /// <param name="type">a Type</param> | ||
265 | /// <returns>a string</returns> | ||
266 | /// <remarks>this is something we'll need to implement for each db slightly differently.</remarks> | ||
267 | public static string sqliteType(Type type) | ||
268 | { | ||
269 | if (type == typeof (String)) | ||
270 | { | ||
271 | return "varchar(255)"; | ||
272 | } | ||
273 | else if (type == typeof (Int32)) | ||
274 | { | ||
275 | return "integer"; | ||
276 | } | ||
277 | else if (type == typeof (UInt32)) | ||
278 | { | ||
279 | return "integer"; | ||
280 | } | ||
281 | else if (type == typeof (Int64)) | ||
282 | { | ||
283 | return "varchar(255)"; | ||
284 | } | ||
285 | else if (type == typeof (UInt64)) | ||
286 | { | ||
287 | return "varchar(255)"; | ||
288 | } | ||
289 | else if (type == typeof (Double)) | ||
290 | { | ||
291 | return "float"; | ||
292 | } | ||
293 | else if (type == typeof (Boolean)) | ||
294 | { | ||
295 | return "integer"; | ||
296 | } | ||
297 | else if (type == typeof (Byte[])) | ||
298 | { | ||
299 | return "blob"; | ||
300 | } | ||
301 | else | ||
302 | { | ||
303 | return "string"; | ||
304 | } | ||
305 | } | ||
306 | } | ||
307 | } | ||
diff --git a/OpenSim/Data/SQLiteNG/SQLiteXInventoryData.cs b/OpenSim/Data/SQLiteNG/SQLiteXInventoryData.cs new file mode 100644 index 0000000..be1d041 --- /dev/null +++ b/OpenSim/Data/SQLiteNG/SQLiteXInventoryData.cs | |||
@@ -0,0 +1,155 @@ | |||
1 | /* | ||
2 | * Copyright (c) Contributors, http://opensimulator.org/ | ||
3 | * See CONTRIBUTORS.TXT for a full list of copyright holders. | ||
4 | * | ||
5 | * Redistribution and use in source and binary forms, with or without | ||
6 | * modification, are permitted provided that the following conditions are met: | ||
7 | * * Redistributions of source code must retain the above copyright | ||
8 | * notice, this list of conditions and the following disclaimer. | ||
9 | * * Redistributions in binary form must reproduce the above copyright | ||
10 | * notice, this list of conditions and the following disclaimer in the | ||
11 | * documentation and/or other materials provided with the distribution. | ||
12 | * * Neither the name of the OpenSimulator Project nor the | ||
13 | * names of its contributors may be used to endorse or promote products | ||
14 | * derived from this software without specific prior written permission. | ||
15 | * | ||
16 | * THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS'' AND ANY | ||
17 | * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | ||
18 | * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | ||
19 | * DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY | ||
20 | * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | ||
21 | * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | ||
22 | * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND | ||
23 | * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | ||
24 | * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | ||
25 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | ||
26 | */ | ||
27 | |||
28 | using System; | ||
29 | using System.Data; | ||
30 | using System.Reflection; | ||
31 | using System.Collections.Generic; | ||
32 | using Mono.Data.Sqlite; | ||
33 | using log4net; | ||
34 | using OpenMetaverse; | ||
35 | using OpenSim.Framework; | ||
36 | |||
37 | namespace OpenSim.Data.SQLite | ||
38 | { | ||
39 | /// <summary> | ||
40 | /// A MySQL Interface for the Asset Server | ||
41 | /// </summary> | ||
42 | public class SQLiteXInventoryData : IXInventoryData | ||
43 | { | ||
44 | // private static readonly ILog m_log = LogManager.GetLogger(MethodBase.GetCurrentMethod().DeclaringType); | ||
45 | |||
46 | private SQLiteGenericTableHandler<XInventoryFolder> m_Folders; | ||
47 | private SqliteItemHandler m_Items; | ||
48 | |||
49 | public SQLiteXInventoryData(string conn, string realm) | ||
50 | { | ||
51 | m_Folders = new SQLiteGenericTableHandler<XInventoryFolder>( | ||
52 | conn, "inventoryfolders", "InventoryStore"); | ||
53 | m_Items = new SqliteItemHandler( | ||
54 | conn, "inventoryitems", String.Empty); | ||
55 | } | ||
56 | |||
57 | public XInventoryFolder[] GetFolders(string[] fields, string[] vals) | ||
58 | { | ||
59 | return m_Folders.Get(fields, vals); | ||
60 | } | ||
61 | |||
62 | public XInventoryItem[] GetItems(string[] fields, string[] vals) | ||
63 | { | ||
64 | return m_Items.Get(fields, vals); | ||
65 | } | ||
66 | |||
67 | public bool StoreFolder(XInventoryFolder folder) | ||
68 | { | ||
69 | return m_Folders.Store(folder); | ||
70 | } | ||
71 | |||
72 | public bool StoreItem(XInventoryItem item) | ||
73 | { | ||
74 | return m_Items.Store(item); | ||
75 | } | ||
76 | |||
77 | public bool DeleteFolders(string field, string val) | ||
78 | { | ||
79 | return m_Folders.Delete(field, val); | ||
80 | } | ||
81 | |||
82 | public bool DeleteItems(string field, string val) | ||
83 | { | ||
84 | return m_Items.Delete(field, val); | ||
85 | } | ||
86 | |||
87 | public bool MoveItem(string id, string newParent) | ||
88 | { | ||
89 | return m_Items.MoveItem(id, newParent); | ||
90 | } | ||
91 | |||
92 | public XInventoryItem[] GetActiveGestures(UUID principalID) | ||
93 | { | ||
94 | return m_Items.GetActiveGestures(principalID); | ||
95 | } | ||
96 | |||
97 | public int GetAssetPermissions(UUID principalID, UUID assetID) | ||
98 | { | ||
99 | return m_Items.GetAssetPermissions(principalID, assetID); | ||
100 | } | ||
101 | } | ||
102 | |||
103 | public class SqliteItemHandler : SQLiteGenericTableHandler<XInventoryItem> | ||
104 | { | ||
105 | public SqliteItemHandler(string c, string t, string m) : | ||
106 | base(c, t, m) | ||
107 | { | ||
108 | } | ||
109 | |||
110 | public bool MoveItem(string id, string newParent) | ||
111 | { | ||
112 | SqliteCommand cmd = new SqliteCommand(); | ||
113 | |||
114 | cmd.CommandText = String.Format("update {0} set parentFolderID = :ParentFolderID where inventoryID = :InventoryID", m_Realm); | ||
115 | cmd.Parameters.Add(new SqliteParameter(":ParentFolderID", newParent)); | ||
116 | cmd.Parameters.Add(new SqliteParameter(":InventoryID", id)); | ||
117 | |||
118 | return ExecuteNonQuery(cmd, m_Connection) == 0 ? false : true; | ||
119 | } | ||
120 | |||
121 | public XInventoryItem[] GetActiveGestures(UUID principalID) | ||
122 | { | ||
123 | SqliteCommand cmd = new SqliteCommand(); | ||
124 | cmd.CommandText = String.Format("select * from inventoryitems where avatarId = :uuid and assetType = :type and flags = 1", m_Realm); | ||
125 | |||
126 | cmd.Parameters.Add(new SqliteParameter(":uuid", principalID.ToString())); | ||
127 | cmd.Parameters.Add(new SqliteParameter(":type", (int)AssetType.Gesture)); | ||
128 | |||
129 | return DoQuery(cmd); | ||
130 | } | ||
131 | |||
132 | public int GetAssetPermissions(UUID principalID, UUID assetID) | ||
133 | { | ||
134 | SqliteCommand cmd = new SqliteCommand(); | ||
135 | |||
136 | cmd.CommandText = String.Format("select inventoryCurrentPermissions from inventoryitems where avatarID = :PrincipalID and assetID = :AssetID", m_Realm); | ||
137 | cmd.Parameters.Add(new SqliteParameter(":PrincipalID", principalID.ToString())); | ||
138 | cmd.Parameters.Add(new SqliteParameter(":AssetID", assetID.ToString())); | ||
139 | |||
140 | IDataReader reader = ExecuteReader(cmd, m_Connection); | ||
141 | |||
142 | int perms = 0; | ||
143 | |||
144 | while (reader.Read()) | ||
145 | { | ||
146 | perms |= Convert.ToInt32(reader["inventoryCurrentPermissions"]); | ||
147 | } | ||
148 | |||
149 | reader.Close(); | ||
150 | //CloseCommand(cmd); | ||
151 | |||
152 | return perms; | ||
153 | } | ||
154 | } | ||
155 | } | ||