I'll run through how the stored procedure functions now and get to the question after. The current procedure accepts an ID number corresponding to a node within a tree - the ID is formatted such that the left substring of a child node contains the ID of its immediate parent. So if a child node has the ID 10100349, then its parent has ID 101003. The procedure returns any information belonging to the selected node and its children by the following:
CREATE PROCEDURE [dbo].[blah]
-- Parameter
#IDNumber varchar(100),
...
-- Get the length of the ID number
DECLARE #IDNumLength integer
SET #IDNumLength = LEN(#IDNumber)
...
SELECT
*whatever information*
WHERE
LEFT(table.[IDNumber], #IDNumLength) = #IDNumber
For illustrative purposes:
1010 (root node)
|
|_ 101001
| |_ 10100101
| |_ 10100102
| |_ 10100103
| |_ 10100104
|
|_ 101002
. |_ 10100201
. |_ 10100202
. |_ 10100203
So searching for information on node 101001 would return information for itself and its child nodes 10100101 through 10100104.
This works fine for when only one ID is selected, but I'm trying to modify the query to accept multiple IDs so that the query returns information for multiple nodes. The selected node IDs are passed in as a comma-delimited string ('101001,10100201,10100202') wherein none of the specified IDs are children of any other node in the string (this is done to avoid duplication of information - this condition is enforced prior to executing the query).
I've done some research into simulating arrays in T-SQL, but anything I've come across involves just searching on any elements in the "array". The problem I'm stuck with is associating a length value with each ID similar to how the single-ID query is formed.
Thanks in advance. If anyone has questions, I'll answer them as best as I can.
I like the idea of separation of concerns, so
First you might want to consider parsing the string
Second, Iterate through your list of strings
pass the a single value to your working sp,
return result to a temp table or table variable depending upon the circumstances.
finally process the completed results
Hope this helps!
Related
I have a PostgreSQL table in an application that holds both parent and child records. There is a column in the table to reference the the parent id where applicable for each child record. The problem is I am trying to import data from an external source where the child record is made up of a sub number of the parent. eg parent_reference_id = 123456000000 and a child_reference record for this could 123456000001, 123456000002 and so on. The application itself generates a unique id for each record when I import the data and so its possible to import the child and parent records simultaneously, however the difficulty I'm facing is linking the application generated id for the parent record to the parent_reference_id for the corresponding child records. The only hook I have is that the 1st six digits of the child_value_reference match the 1st six digits of the parent_value_reference and I've tried something like foo = bar(left(value,6)||'000000'; to create a match. However, I don't know how to use this to return the unique_id in a meaningful way and update the matching records. I've tried temporary tables and cte, however my knowledge of postgres is limited and I can't seem to find a solution that fits my problem. Another thing to mention is that these groups can change with updates within the external data so i'd also need a solution to make those updates too. Thanks in advance, Crispian
I have two entities in my dynamo table: User and Order.
Each user has 0..* orders and each order has exactly one associated user. Every order also has a orderDate attribute, that describes when the order was placed.
My current table is structured as follows to make retrieving all orders for a specific user efficient:
+--------------+----------------+--------------------------------------+
| PK | SK | Attributes |
+--------------+----------------+-------------+-----------+------------+
| | | name | firstName | birthDate |
+--------------+----------------+-------------+-----------+------------+
| USER#userid1 | META#userid1 | Foo | Bar | 2000-10-10 |
+--------------+----------------+-------------+-----------+------------+
| | | orderDate | | |
+--------------+----------------+-------------+-----------+------------+
| USER#userid1 | ORDER#orderid1 | 2020-05-10 | | |
+--------------+----------------+-------------+-----------+------------+
I now have a second access pattern where I want to query all orders (regardless of user) that were placed on a specific day (e.g. 2020-05-10) along with the the user(s) that placed them.
I'm struggling to handle this access pattern in my table design. Neither GSIs nor different primary keys seem to work here, because I either have to duplicate every user item for each day or I can't query the orders together with the user.
Is there an elegant solution to my problem?
This is a perfect use case for a secondary index. Here's one way to do it:
You could create a secondary index (GSI1) on the Order item with a Partition Key (GSI1PK) of ORDERS#<orderDate> and a Sort Key (GSI1SK) of USER#<user_id>. It would look something like this:
The logical view of your GSI1 would look like this:
GSI1 would now support a query of all orders placed on a specific day.
Keep in mind that denormalizing your data model (e.g. repeating user info in the Order item) is a common pattern utilized in DynamoDB data modeling. Remember, space is cheap! More importantly, you are pre-joining your data to support your applications access patterns. In this instance, I'd add whatever User metadata you need to the Order item so it gets projected into the index.
Make sense?
Unfortunately, I can't seem to figure out a way to elegantly solve your problem.
You need to either duplicate the user info and store in the order record or use a second getItem to query the user-specific info.
If anyone has better solutions, please let me know.
I am completing an exercise using DynamoDB to model a many to many relationship. I need to allow a many to many relationship between posts and tags. Each post can have many tags and each tag can have many posts.
I have a primary key on id and primary sort key on type and then another global index on id and data, I added another global index on id and type again but I think this is redundant.
Here is what I have so far.
id(Partition key) type(Sort Key) target data
------------- ---------- ------ ------
1 post 1 cool post
tag tag tag n/a
1 tag tag orange
---------------------------------------------
---- inserting another tag will overwrite ---
---------------------------------------------
1 tag tag green
I am taking advice from this awesome talk https://www.youtube.com/watch?v=jzeKPKpucS0 and these not so awesome docs https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/bp-adjacency-graphs.html
The issue I am having is that if I try to add another tag with an id "1" and type "tag" it will overwrite the existing tag because it would have the same composite key. What am I missing here? It seems like the suggestion is to make the primary key and sort key be the id and type. Should I have my type be more like "tag#orange"? In that case I could put a global index on the target with a sort key on the type. This way I could get all posts with a certain tag by querying target = "tag" and type starts with "tag".
Just looking for some advice on handling this sort of adjacency list data with Dynamo as it seems very interesting. Thanks!
Basic guidelines for an adjacency-list
You need a few modifications to the way you're modeling. In an adjacency-list you have two types of items:
Top-level (those are your Posts and Tags)
Association (expresses which Tags are associated with each Post and vice-versa)
To build this adjacency-list, you must follow two simple guidelines (which I think are missing in your example):
Each top-level item (in your case a Post or a Tag) must be represented using the primary-key. Also, those items should have the same value in the sort-key and the primary-key
For associations, use the primary-key to represent the source (or parent) and the sort-key to represent the target (or child).
From what I see in your examples, you set the primary-key of your Posts and Tags as just the item ID, while you should also use its type; e.g. Post-1 or Tag-3. In items that represent associations, I also don't see you storing the target ID.
Example
Let's say you have:
Three Posts: "hello world", "foo bar" and "Whatever..."
And three tags: "cool", "awesome", "great"
Post "hello world" has one tag: "cool"
Post "foo bar" has two tags: "cool" and "great"
Post "Whatever..." doesn't have any tags
You'd need to model this way in Dynamo:
PRIMARY-KEY | SORT-KEY | SOURCE DATA | TARGET DATA
--------------|-------------|--------------|-------------
Post-1 | Post-1 | hello world |
Post-2 | Post-2 | foo bar |
Post-3 | Post-3 | Whatever... |
Tag-1 | Tag-1 | cool |
Tag-2 | Tag-2 | awesome |
Tag-3 | Tag-3 | great |
Post-1 | Tag-1 | hello world | cool
Post-2 | Tag-1 | foo bar | cool
Post-2 | Tag-3 | foo bar | great
Tag-1 | Post-1 | cool | hello world
Tag-1 | Post-2 | cool | foo bar
Tag-3 | Post-2 | great | foo bar
How you query this adjacency list
1) You need a particular item, say Post-1:
Query primary-key == "Post-1" & sort-key == "Post-1" - returns: only Post-1
2) You need all tags associated with Post-2:
Query by primary-key == "Post-2" & sort-key BEGINS_WITH "Tag-" - returns: Tag-1 and Tag-3 associations.
Check the documentation about the begin_with key condition expression.
3) You need all Posts associated with, say Tag-1:
Query by primary_key == "Tag-1" & sort-key BEGINS_WITH "Post-" - returns: Post-1 and Post-2 associations.
Note that, if you change the contents of a given post, you need to change the value in all association items as well.
You can also don't store the post and tag content in association items, which saves storage space. But, in this case, you'd need two queries in the example queries 2 and 3 above: one to retrieve associations, another to retrieve each source item data. Since querying is more expensive than storing data, I prefer to duplicate storage. But it really depends if your application is read-intensive or write-intensive. If read-intensive, duplicating content in associations gives you benefit of reducing read queries. If write-intensive, not duplicating content saves write queries to update associations when the source item is updated.
Hope this helps! ;)
I don't think you are missing anything. The idea is that ID is unique for the type of item. Typically you would generate a long UUID for the ID rather than using sequential numbers. Another alternative is to use the datetime you created the item, probably with an added random number to avoid collisions when items are being created.
This answer I have previously provided may help a little DynamoDB M-M Adjacency List Design Pattern
Don't remove the sort key - this wont help make your items more unique.
We have a people table, each person has a gender defined by a gender_id to a genders table,
| people |
|-----------|
| id |
| name |
| gender_id |
| genders |
|---------|
| id |
| name |
Now, we want to allow people to create forms by themselves using a nice form builder. One of the elements we want to add is a select list with user defined options,
| lists |
|-------|
| id |
| name |
| list_options |
|--------------|
| id |
| list_id |
| label |
| value |
However, they can't use the genders as a dropdown list because it's in a different table. They could create a new list with the same options as genders but this isn't very nice and if a new gender is added they'd need to add it in multiple places.
So we want to move the gender options into a list that the user can edit at will and will be reflected when a new person is created too.
What's the best way to move the genders into a list and list_options while still having a gender_id (or similar) column in the people table? Thoughts I've had so far include;
Create a 'magic' list with a known id and always assume that this contains the gender options.
Not a great fan of this because it sounds like using 'magic' numbers. The code will need some kind of 'map' between system level select boxes and what they mean
Instead of having a 'magic' list, move it out into an option that the user can choose so they have a choice which list contains the genders.
This isn't really much different, but the ID wouldn't be hardcoded. It would require more work looking through DB tables though
Have some kind of column(s) on the lists table that would mark it as pulling its options from another table.
Would likely require a lot more (and more complex) code to make this work.
Some kind of polymorphic table that I'm not sure how would work but I've just thought about and wanted to write down before I forget.
No idea how this would work because I've only just had the idea
The easiest solution would change your list_options table to a view. If you have multiple tables you need have a list drop down for to pull from this table, just UNION result sets together.
SELECT
(your list id here) -- make this a part primary key
id, -- and this a part primary key
Name,
FROM dbo.Genders
UNION
SELECT
(your list id here) -- make this a part primary key
id, -- and this a part primary key
Name,
FROM dbo.SomeOtherTable
This way it's automatically updated anytime the data changes. Now you are going to want to test this, as if this gets big it might get slow, you can get around this by only pulling all this information once in your application (or say cache it for 30 minutes and then refresh just in case).
Your second option is to create a table list_options and then create a procedure (etc.) which goes through all the other lookup tables and pulls the information to compile it. This will be faster for application performance, but it will require you to keep it all in sync. The easiest way to handle this one is to create a series of triggers which will rebuild portions (or the entire) list_options table when something in the look up tables is changed. In this one, I would suggest moving away from creating a automatically generated primary key and move to a composite key, like I mentioned with the views. Since this is going to be rebuilt, the id will change, so it's best to not having anything think that value is at all stable. With the composite (list_id,lookup_Id) it should always be the same no matter how many times that row is inserted into the table.
I have a number of tables in an MS Access Db that have to use Replication IDs (GUID) as the primary key (and therefore also as foreign key contraints in the relationships between them). The data for these tables comes from an external application and I can't use any other field as a primary as they aren't unique. (I've also chosen, not to use local integer keys, "in loco parentis" for the GUID).
The database worked fine and all the relationships worked as expected and I am able to present the related records in a hierarchical MS Access form (one-to-many-to-many). The problem occurs when I try to present a count as part of the relationhips.
If I have GUIDInParent and GUID in Child as two fields, I can get the children by creating a form with Source Object = ParentToChildRelationship and Link Master Field = GUIDInParent and Link Child Field = GUIDInChild.
However, if I want indicate how many Chidren I'm going to display (since they may be hidden under a scrolled section), I use a separate form field populated via a DCount("1", "ParentToChildRelationship", "[GUIDinChild] = '" & [GUIDInParent] & '")
For the GUID field - this doesn't work... The reason appears to be that while on the form, the GUID (Replication ID) displays as a "GUID" - of the form "{HHHHHHH-HHHH-HHHH-HHHH-HHHHHHHHHHHH}" when assigned to another field it (literally) displays as "Chinese". Even assigning via the GUIDAsString function doesn't change this.
What's going on an is there any way I can use these GUIDs as I intend?
I have "jury rigged" a solution by having two columns in the tables (GUID - as number and GUIDString - as string) both set tot he same value and using the rendering that works in each case...
The DCount("1", "ParentToChildRelationship", "[GUIDinChild] = '" & [GUIDInParent] & '") thus becomes:
DCount("1", "ParentToChildRelationship", "[GUIDinChild] = '" & [GUIDInParentString] & '")
and thus works...
TIA,
Paolo
Have you considered a control in the subform footer to count the records? This can be referenced in the main form by name. Alternatively, you can refer to MySubformControl.Form.Recordset.Recordcount