{"id":2144,"date":"2016-01-13T00:00:00","date_gmt":"2016-01-13T00:00:00","guid":{"rendered":"https:\/\/test.simple-talk.com\/uncategorized\/data-manipulation-in-r-beyond-sql\/"},"modified":"2021-05-03T14:02:02","modified_gmt":"2021-05-03T14:02:02","slug":"data-manipulation-in-r-beyond-sql","status":"publish","type":"post","link":"https:\/\/www.red-gate.com\/simple-talk\/development\/dotnet-development\/data-manipulation-in-r-beyond-sql\/","title":{"rendered":"Data Manipulation in R: Beyond SQL"},"content":{"rendered":"
\n

R is an extremely versatile statistical analysis platform.  It is designed to perform complex calculations using only a few interactive commands or a short script.  Many R users initially use the language to create a statistical summary or chart using a tiny subset of the available functionality.   The R-Basics<\/a> and Visualizing Data with R<\/a> articles introduce these topics, but don’t go into much detail about how to manipulate datasets within R.  <\/p>\n

 A subsequent article describes the use of SQL and R<\/a> for interacting with databases and manipulating data frames.  The R community has created a number of SQL-related packages available from CRAN<\/a> (the Comprehensive R Archive Network). Many of these allow R to query and process data in relational databases, but others (like sqldf<\/a>) can be used with data that does not explicitly originate in, or target, a relational database.  The availability of SQL within R is incredibly valuable for many data problems, particularly if you “think” in SQL.   A dataset can be conveniently sorted, filtered, manipulated, re-ordered and analyzed.  These basic operations are intrinsic to SQL and applicable to any dataset that conforms to the “shape” of a standard database results set.<\/p>\n

SQL is a well-understood standard language that is familiar to many developers and analysts.  It is used in most modern relational databases and has influenced similar query languages on non-relational platforms.   R syntax can be confusing when initially encountered, so if you are comfortable using SQL, you can use it to jump-start your development on R.<\/p>\n

 Although SQL is a popular way to process data frames, there are situations where a different approach is warranted.  Certain data transformations are notoriously difficult to express using SQL.   Such transformations require complex, obscure syntax or multiple statements executed in sequence.  The core R programming language and a number of publicly available packages can be leveraged to easily accomplish such tasks.<\/p>\n

Complex SQL Not Required<\/h2>\n

Operations that are conceptually simple can be difficult to perform using SQL.  Consider the common requirements to pivot or transpose a dataset.   Each of these actions are conceptually straightforward but are complex to implement using SQL.  The examples that follow are somewhat verbose, but the details are not significant. The main point is to illustrate is that, by using specialized functions outside of SQL,  R makes trivial some of those operations that would otherwise require complex SQL statements.  The contrast in the amount of code required is striking.  The simpler approach allows you to focus attention on the scientific or business problem at hand, rather than expending energy reading documentation or laboriously testing complex statements.<\/p>\n

Example 1: The Pivot<\/h3>\n

Pivoting a table (also known as cross tabulation) involves transforming certain data elements into columns.  This task will introduce the reshape2<\/span> package.  If you are following along and have not installed the package, you will have to do so using the RStudio GUI or at the command prompt by running.<\/p>\n

install.packages('reshape2')<\/pre>\n
Once installed, the library needs to be included in the  current R session.<\/p>\n
library(reshape2)     <\/pre>\n
Note that an earlier  less optimized package named “reshape”<\/a> provides similar functionality and a  corresponding API.  It’s will not be  used in the examples that follow.<\/p>\n
Many relational databases have PIVOT<\/span> and  UNPIVOT <\/span>functions  to create a crosstab report.  Examples  using SQLServer are presented in other  posts on Simple-Talk<\/a>.  This  syntax is consistent with other RDBMS implementations.  Consider a results set returned by a query on Oracle’s HR demonstration  schema.<\/p>\n
select job_id, department_name, sum(salary) salary \n     from  DEPARTMENTS d \n     join EMPLOYEES e on e.DEPARTMENT_ID = d.DEPARTMENT_ID\n     where job_id in ('ST_MAN','AD_ASST','PU_MAN','SH_CLERK')\n     group by job_id, department_name;\n<\/pre>\n
The results represent the total salary for a given job  title within a department.    <\/b><\/p>\n
JOB_ID        DEPARTMENT_NAME SALARY\nAD_ASST       Administration  4400\nST_MAN        Shipping        36400\nPU_MAN        Purchasing      11000\nSH_CLERK      Shipping        64300\n<\/pre>\n
You can create a dataframe in R to hold this data and view  it as follows:<\/p>\n
df<- data.frame(\n  JOB_ID=c('AD_ASST','ST_MAN','PU_MAN', 'SH_CLERK'),\n  DEPARTMENT_NAME = c('Administration','Shipping','Purchasing','Shipping'),\n  SALARY=c(4400, 36400, 11000, 64300)\n)\n \nView(df)\n \n<\/pre>\n
  \"2341-clip_image002.jpg\"<\/b><\/b><\/p>\n
The View()<\/code> command is used to provide the spreadsheet-like  view of the data.  It will be omitted  in subsequent examples.   Any  example that returns data can simply be wrapped in a View()<\/code> method call to be  viewed in this manner.<\/p>\n
A pivot operation applied to the operation results in each  department name being used as a column.   Essentially, the original query is wrapped in and a pivot clause is  appended.  The pivot clause lists the  data value and column names to use.   <\/p>\n
select * from \n  (select job_id, department_name, sum(salary) salary \n     from  DEPARTMENTS d \n     join EMPLOYEES e on e.DEPARTMENT_ID = d.DEPARTMENT_ID\n     where job_id in ('ST_MAN','AD_ASST','PU_MAN','SH_CLERK')\n     group by job_id, department_name)\npivot (\n  sum(salary) for (department_name) in (\n    'Administration',\n    'Purchasing',\n    'Shipping') \n) order by 1;\n<\/pre>\n
The results contain the same data presented in a pivot  format.<\/p>\n
JOB_ID Administration Purchasing    Shipping\nAD_ASST          4400               \nPU_MAN                     11000          \nSH_CLERK                               64300\nST_MAN                                36400\n<\/pre>\n
Earlier SQL developers devised clever but notoriously  complicated solutions before the PIVOT <\/span>function was implemented.   Some relied upon non-standard database specific functionality while  others required several queries to be executed to create intermediate results  before creating the final crosstab report.  The PIVOT <\/span>function is an improvement, but remains a fairly verbose option  when compared with the ability to “cast” a database using a function from the  reshape2 <\/span>package.  <\/p>\n
df2<- dcast(df, JOB_ID ~  DEPARTMENT_NAME)<\/pre>\n
  \"2341-clip_image004.jpg\"<\/b><\/b><\/p>\n
Example 2: The Transpose<\/h3>\n
Transposing a dataset involves rotating a result set so  that the rows from the original result set are columns in the final result set.  This relatively simple idea is surprisingly difficult to express in SQL  (though it is  certainly possible<\/a>).   No  special packages are required.  The R  base language contains a built in transpose function.   We could just proceed to transpose, but the dataset as represented has an  inconsistency.  The column names are  not part of the dataset, but the row names are.  SQL has a concept of column names but not row names.  Our results will be a bit neater if we assign row names based on  JOB_IDs <\/span>and remove the JOB_ID <\/span>column from the data.  These two statements enact these changes.<\/p>\n
rownames(df2) <- df2$JOB_ID\ndf2<-df2[-1]\n \n<\/pre>\n
We will pause here for a moment to consider a few aspects  of R that are a bit surprising.  Most  programming languages do not support a function call on a variable that is the  recipient of an assignment, yet R allows you to return the row names of the data  frame and use the returned value as the recipient of an assignment.  In addition, most languages require that each item in a collection be  assigned individually.  This often  requires a looping construct to iterate through each available assignment target  and value.  R, being vector based,  allows the set of row names associated with the data frame to be assigned all at  once.  <\/p>\n
The second line shows one of several methods available to  remove a column.  In this case, the  minus sign indicates a column should be deleted.  R, being one-based rather than zero based like many other programming  languages, interprets this to mean “return a data frame like the current data  frame without the first column.”   This value is then assigned back to the variable that held the original  reference to the data frame.   <\/p>\n
The net effect is that the first column disappears from the  dataset and row names are now associated with the data frame.<\/b><\/p>\n
 \"2341-clip_image006.jpg\"<\/p>\n
The idea of transposing a matrix is a well-understood  concept in linear algebra and is commonly used in statistical analysis.  Since it has a long history of providing statistical functions, R  included matrix manipulation from its earliest days.  All that is required to flip the data frame is to call the t function.<\/p>\n
t(df2)<\/pre>\n
 \"2341-clip_image008.jpg\"<\/p>\n
That’s all there is to it!  There are some limitations.   But in this case, with consistent numeric data and column and row names outside  of the dataset proper, the conversion works as expected.   Lets look at a different example where the limitations become evident.<\/p>\n
Recall the “mtcars<\/span>” dataset introduced in a previous  post<\/a> that is derived from 1974 Motor Trend US magazine data (hence the “mt”  in the dataset name). The dataset describes fuel consumption and various aspects  of automobile design and performance for 32 automobiles.  <\/p>\n
 \"2341-clip_image010.jpg\"<\/p>\n
When this dataset is transposed, the columns names are car  names and the row names are features of a car.  Values in individual cells of the data frame that were originally  integers are cast to decimals.<\/p>\n
t(mtcars)<\/pre>\n
 \"2341-clip_image012.jpg\"<\/p>\n
The fundamental difference between data frames and matrices  in R is that matrices can only contain a single data type while data frames can  have a different data type in each column.   The transpose function first converts the data frame to a matrix – so all  data is converted to the “least common denominator” data type.  This is evident in the mtcars dataset in the gear column.<\/p>\n
In the worst case, you end up with a bunch of strings,  which is often not intended.  This  can happen if row names are included as part of your dataset rather than being  part of the metadata of the data frame accessible using the rownames function.<\/p>\n
More Reshaping of Data<\/h2>\n
The reshape2 <\/span>includes two methods (“melt<\/span>” and “cast<\/span>“) to  change the form, but not the content of a data frame.   The base R language can perform  comparable transformations, but uses a number of different functions and  operators that are not particularly unified or consistent.  The reshape2 <\/span>package provides a streamlined and consistent syntax for  these operations.<\/p>\n
Before we begin, we will manipulate row names using the  inverse of the operation shown earlier.   Rather  than pulling a column out of the dataset and assigning the column values as row  names, the row names will be included inline in the dataset.<\/p>\n
df<-mtcars\ndf$car_name <- rownames(mtcars)\n<\/pre>\n
The melt <\/span>function takes each column and represents the data  by creating a column to hold the (old) column name and a second column to hold  the actual value.  Any columns listed  in the id vector are retained. <\/p>\n
melt(df, id=\"c(\"\"car_name\"))<\/pre>\n
  <\/b><\/p>\n
  \"2341-clip_image014.jpg\"<\/b><\/b><\/p>\n
The variable column contains entries for each column in the  original dataset (mpg, cyl, disp, hp, etc).  A row is created for each value associated.  This presents the data in a “long” rather than a “wide” format.<\/p>\n
The default version of the function selects an  id <\/span>column to  use based on data types available (and works as expected with  df<\/span>).   When called in this manner, all columns  with numeric values are treated as variables with values and the  car_name <\/span>column  is assumed to be an id column.  So  the results are the same as those shown above.<\/p>\n
melt(df)<\/pre>\n
This function selects the “name<\/span>” column by default with the  current dataset.  In this example, we  named the column car_name as it is more explicit, and it prevents problems with  other functions that treat columns named “name<\/span>” in a special way.  <\/p>\n
Just to emphasize, this is not the only way to use the  melt <\/span>function, and different results are possible by modifying the call to this  function.  The following example  retains the gear data in a column along with the name <\/span>column as previously  shown.<\/p>\n
melt(df, id=\"c(\"\"car_name\",\"gear\"))<\/pre>\n
 \"2341-clip_image016.jpg\"<\/p>\n
The gear column is not included as a value in the variable  data, but instead is retained as a column.   As a result, the total number of rows in the dataset is reduced.  The data is a bit “wider” than the previous example, but it is not a  particularly practical arrangement.<\/p>\n
We will store the melted data in a second data frame.<\/p>\n
melted <- melt(df, id=\"c(\"\"car_name\"))<\/pre>\n
The complementary function for melt is cast.  There are a few variations on this function that allow you to choose what  data structure is returned.  We will  use the dcast variation that returns results as a data frame. We will store the  results in a variable and will look at them a bit closer in the next section.<\/p>\n
df2 <- dcast(melted, car_name ~ variable, value.var = c(\"value\")) <\/pre>\n
The tilde ~ operator is typically used in R to separate the  left and right hand sides of a formula.  While the data has been converted back and forth without changing the  content of the data, the row and column order may have changed.   <\/p>\n
At this point we have two data sets, the original, and a  second dataset that has been melted and recast.  To do a final comparison that demonstrates these are identical, we need  to perform a few operations that order the columns and rows.  If we don’t perform these steps, the two  data frames will be considered “not equal” simply because the rows or columns  are ordered differently.  These steps  essentially “normalize” the datasets by sorting the columns and rows in  alphabetical order by row name.<\/p>\n
The row names is stored in alphabetical order in a vector.<\/p>\n
cn <- sort(colnames(df))<\/pre>\n
Two new dataframes are created containing the data with the  columns in alphabetical order.<\/p>\n
original<- df[cn]\nreshaped<- df2[cn]\n<\/pre>\n
The data itself is reordered so that rows are in  alphabetical order by name.<\/p>\n
original <- original[order(original$car_name),]\nreshaped <- reshaped[order(reshaped$car_name),]\n<\/pre>\n
Because rownames are metadata and we have included them as  the names column in the data frames, we will not consider them in the comparison  of the two data frames.<\/p>\n
rownames(reshaped)<-NULL\nrownames(original)<-NULL\n<\/pre>\n
With these arrangements in place, the original dataset and  the melted-recast dataset contain the same data.<\/p>\n
all.equal(original, reshaped)\n<\/pre>\n
The function call returns TRUE, indicating that the two  data frames contain identical values.  If you wanted to retain this set of transformations for use in subsequent  tests, you can use the following function.<\/p>\n
normalize_df <- function(df, sort_column){\n  cn <- sort(colnames(df))\n  df <- df[cn]\n  df <- df[order(df[sort_column]),]\n  rownames(df) <- NULL\n  return(df)\n}\n<\/pre>\n
This function can compare the data frames without the need  to run each normalization step manually.<\/p>\n
all.equal(\n  normalize_df(df,  'car_name'), \n  normalize_df(df2, 'car_name')\n)\n\t<\/pre>\n
R lends itself to simple interactive examples.  Functions like this suggest one of the most useful techniques to learn  the R language.   In a few lines  of code, a function of this sort can be created to verify an operation is  behaving as expected.  Often the best  way to ensure you understand what R is doing is to create simple examples to  test and validate your expectations. <\/p>\n
Reshaping and Tidy Data<\/h2>\n
Programming languages can be classified by basic philosophy  that drives the design of the language and impact subsequent community activity  such as package development.    TIMTOWTDI<\/a> (pronounced “Tim Toady”) stands for “There is more than one way to  do it” and was popularized by the Perl community.  While some programmers appreciate the flexibility afforded by such an  approach, others are irritated by the ambiguity introduced.  Languages like Python take the opposite approach and are designed so that  there is only one way to do things whenever possible. Regardless of your opinion  on the best approach, it is important to realize that R packages have  significant overlap in terms of functionality.  Often features available in the base language are packaged as a domain  specific language in a particular package for consistency or convenience.  An awareness of this fact will prevent confusion and make you more  effective at selecting packages to rapidly solve problems.<\/p>\n
The tidyr <\/span>package includes functionality found in the reshape2 <\/span>package but the overall design has a different purpose.  Load up the package to see the similarities demonstrated below.<\/p>\n
library(tidyr)<\/pre>\n
The tidyr <\/span>package contains methods that correspond to  melt <\/span>and cast<\/span>:  gather and spread.  The gather <\/span>function is called along with the “bare” column name – the  name of the column without enclosing it in quotes.<\/p>\n
melted_tidyr <- gather(df, car_name)<\/pre>\n
The only difference between the dataframe in this case with  the one produced by reshape2 <\/span>is the rownames.  The all.equal method includes an option to ignore the rownames.<\/p>\n
all.equal(melted, melted_tidyr, check.names=FALSE)<\/pre>\n
The function call returns TRUE<\/span>.  We will ensure that the column names are unique by explicitly naming them  and then call the spread <\/span>function to convert the data back to its original  format.<\/p>\n
colnames(melted_tidyr ) <- c('car_name', 'variable', 'value')\nspread_tidyr <- spread(melted_tidyr, variable, value)\n<\/pre>\n
The final result is a data frame that matches the original  (once the data frames are normalized).<\/p>\n
all.equal(\n  normalize_df(df, 'car_name'), \n  normalize_df(spread_tidyr, 'car_name')\n)\n\t<\/pre>\n
The reshape2 <\/span>package is designed for general purpose  reshaping of data.  The  tidyr <\/span>package  is specifically designed for getting data into a “tidy” format.  Hadley Wickham coined the term “Tidy  Data<\/a>” and is the author of the packages referenced in this article.  It is a standardized form for data – closely related to the idea of  normal forms in databases – that simplifies subsequent analysis and processing.<\/p>\n
SQL-like Manipulations in a Functional Style<\/h2>\n
SQL is the standard language for manipulating data in  relational databases and has influenced a variety of query languages in  non-relational data stores.  It can  be used to manipulate data frames in R using the sqldf package.  The dplyr package provides functions comparable to those available in  SQL.  <\/p>\n\n\n\n\n\n\n\n\n
\n
SQL Keyword<\/b><\/p>\n<\/td>\n
\n
dplyr<\/b><\/p>\n<\/td>\n<\/tr>\n
\n
SELECT<\/p>\n<\/td>\n
\n
select, mutate<\/p>\n<\/td>\n<\/tr>\n
\n
WHERE<\/p>\n<\/td>\n
\n
filter<\/p>\n<\/td>\n<\/tr>\n
\n
ORDER BY<\/p>\n<\/td>\n
\n
arrange<\/p>\n<\/td>\n<\/tr>\n
\n
GROUP BY<\/p>\n<\/td>\n
\n
group_by<\/p>\n<\/td>\n<\/tr>\n
\n
HAVING<\/p>\n<\/td>\n
\n
filter<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n
Besides its practical usefulness, the package is  interesting as it provides a different way of constructing data manipulation  that is based on functional programming and pipes rather than SQL statements.  The value of this approach becomes more apparent when long complex  queries consisting of nested subqueries are replaced with a chain of piped  functions.<\/p>\n
The dplyr <\/span>package was introduced in the R-Basics  post<\/a>.    The dplyr<\/b> library uses the operator (%>%) to stream the results of one  function to the next (like UNIX pipes).   This operator is available as soon as the library is loaded and can be  used with functions that are not part of dplyr itself.<\/p>\n
library(dplyr)<\/pre>\n
SELECT<\/h3>\n
The functions that correspond to the SQL  SELECT <\/span>statement  are select<\/span>() and mutate<\/span>().  We will  use a piping operator to chain together calls on the data frame based on the  mtcars <\/span>data frame.  The  mutate <\/span>column  is used to add derived data frame columns.  In this case, we will append the car name, the number of cylinders and  the string literal cylinder.  This  new column will be named description.  We then filter which columns will be viewable and restrict them to the  new description column and the gear column.  Finally, we will pipe to the View <\/span>function (which is not part of  dplyr<\/span>)  which will display the final result. <\/p>\n
df %>% \n  mutate(description=paste(car_name, cyl, 'cylinder')) %>%\n  select(description, gear) %>% \n  View()\n \n<\/pre>\n
  \"2341-clip_image018.jpg\"<\/b><\/b><\/p>\n
ORDER BY<\/h3>\n
The ORDER BY function is used to sort the data based on one  or more columns.  The arrange  function is the dplyr equivalent.   <\/p>\n
df %>% select(car_name) %>% arrange(car_name) %>% View() <\/pre>\n
  \"2341-clip_image020.jpg\"<\/b><\/b><\/p>\n
GROUP BY<\/h3>\n
The SQL GROUP BY<\/span> clause is used in close conjunction with  aggregate functions like SUM() <\/span>and  MEAN()<\/span>.  The clause indicates the level of grouping at which a given summary  function is applied.  When using  the dplyr<\/span> package, it is common practice  to use the summarize <\/span>and  group_by  <\/span>functions together.<\/p>\n
df %>% group_by(cyl) %>% summarize(mean(hp)) %>% View()<\/pre>\n
 \"2341-clip_image022.jpg\"<\/p>\n
In SQL, it is necessary to list the columns referenced in  the GROUP BY<\/span> clause in the SELECT<\/span> clause – along with any aggregate functions.  The dplyr<\/span> package just requires you to specify the function used to  aggregate in the summarize clause.   The dplyr<\/span> functions can be chained together in creative ways that would require  nested subqueries in SQL.  For  instance, if you wanted to compare the average just calculated with the actual  value in each row, this can be accomplished using the mutate<\/span> function rather  than summarize.<\/p>\n
df %>% group_by(cyl) %>% \n   mutate(mhp=mean(hp)) %>% \n   select(cyl, hp, mhp) %>%\n   arrange(cyl, hp) %>% View()\n<\/pre>\n
 \"2341-clip_image024.jpg\"<\/p>\n
WHERE\/HAVING<\/h3>\n
The WHERE <\/span>clause in SQL is used to filter which rows are  returned.  The  HAVING <\/span>clause is used  when evaluating summaries that rely upon a GROUP BY<\/span>.  The simplest case is filtering using an equality operator.  <\/p>\n
df %>% filter(car_name=='Volvo 142E') %>% View()<\/pre>\n
 \"2341-clip_image026.jpg\"<\/p>\n
This example is essentially the same usage that you would  obtain using a WHERE <\/span>clause in SQL.   The next example uses an aggregate function inside<\/i> of a filter function.  This corresponds with the SQL HAVING <\/span>clause.  Note that the results include records which have an actual horse power  (hp) that is less than 200.  However,  they are part of the grouping (by cyl) that is greater than 200.<\/p>\n
 \ndf %>% group_by(cyl) %>% \n       mutate(mhp=mean(hp)) %>% \n       filter(mhp > 200 & mpg < 17) %>% \n       select(car_name, mhp, hp, mpg) %>% \n       View()\n<\/pre>\n
 \"2341-clip_image028.jpg\"<\/p>\n
As this example illustrates, the arrangement of functions  in a chain is less restrictive than the structure of SQL queries.  Each function is independent and discrete, whereas a unit of work in SQL  is a statement that must contain a SELECT <\/span>and may contain the other clauses  referenced.   SQL statements can  be nested using subqueries to effectively “chain” together SQL statements.   The dplyr function interface is less verbose and more focused on the  specific aspects of the data that are changing with each step processed.  <\/p>\n
R a Data Manipulation Platform<\/h2>\n
SQL is – by definition – a query language.  It excels at retrieving data from a database and is in fact essential in  many situations where it is the only way to get data out of a database.<\/p>\n
However, SQL can be cumbersome when it is used to transform  data.  SQL is very flexible and so  does support the ability to transform data in significant ways, but often with  the cost of requiring verbose, obscure, and difficult to support SQL statements.  R includes a number of packages that can perform such operations in a  concise, clear, simple manner.    It is well worth the time to learn these packages so that the best aspects of  both SQL and R packages can be used to analyze data using a series of steps that  is easy to understand and comprehend.<\/p>\n<\/p><\/div>\n","protected":false},"excerpt":{"rendered":"
Although SQL is an obvious choice for retrieving  the data for analysis, it strays outside its comfort zone when dealing with pivots and matrix manipulations. R includes a number of packages that can do these simply. By combining the two, you can prepare your data for analysis or visualisation in R more efficiently.…<\/p>\n","protected":false},"author":177915,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[143538],"tags":[4143,4178,6011,4150],"coauthors":[],"class_list":["post-2144","post","type-post","status-publish","format-standard","hentry","category-dotnet-development","tag-net","tag-bi","tag-software-tools","tag-sql"],"acf":[],"_links":{"self":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/2144","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/users\/177915"}],"replies":[{"embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/comments?post=2144"}],"version-history":[{"count":5,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/2144\/revisions"}],"predecessor-version":[{"id":90788,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/posts\/2144\/revisions\/90788"}],"wp:attachment":[{"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/media?parent=2144"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/categories?post=2144"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/tags?post=2144"},{"taxonomy":"author","embeddable":true,"href":"https:\/\/www.red-gate.com\/simple-talk\/wp-json\/wp\/v2\/coauthors?post=2144"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}