Skip to main content
added some motivation part
Source Link
Kaveh
  • 22.5k
  • 4
  • 52
  • 112

According to Immerman, the complexity class associated with SQL queries is exactly the class of safe queries in $\mathsf{Q(FO(COUNT))}$ (first-order queries plus counting operator): SQL captures safe queries. (In other words, all SQL queries have a complexity in $\mathsf{Q(FO(COUNT))}$, and all problems in $\mathsf{Q(FO(COUNT))}$ can be expressed as an SQL query.)

IsBased on this result, from theoretical point of view, there are many interesting problems that can be solved efficiently but are not expressible in SQL. Therefore an extension of SQL (implemented and used in the industry) which captures $\mathsf{P}$,, i.eis still efficient seems interesting. that can express all polynomial-time computable queries and no others?So here is my question:

Is there an extension of SQL (implemented and used in the industry) which captures $\mathsf{P}$ (i.e. can express all polynomial-time computable queries and no others)?

I want a database query language which stisfies all three conditions. It is easy to define an extension which would extend SQL and will capture $\mathsf{P}$. But my questions is if such a language makes sense from the practical perspective, so I want a language that is being used in practice. If this is not the case and there isn't, is no such language, then I would like to know if there is a reason that makes such a language uninteresting from the practical viewpoint? AreFor example, are the queries that are neededrise in practice usually simple enough that there is no need for such a stronger language?

According to Immerman, the complexity class associated with SQL queries is exactly the class of safe queries in $\mathsf{Q(FO(COUNT))}$ (first-order queries plus counting operator): SQL captures safe queries. (In other words, all SQL queries have a complexity in $\mathsf{Q(FO(COUNT))}$, and all problems in $\mathsf{Q(FO(COUNT))}$ can be expressed as an SQL query.)

Is there an extension of SQL (implemented and used in the industry) which captures $\mathsf{P}$,, i.e. that can express all polynomial-time computable queries and no others?

If there isn't, is there a reason? Are the queries that are needed in practice usually simple enough that there is no need for a stronger language?

According to Immerman, the complexity class associated with SQL queries is exactly the class of safe queries in $\mathsf{Q(FO(COUNT))}$ (first-order queries plus counting operator): SQL captures safe queries. (In other words, all SQL queries have a complexity in $\mathsf{Q(FO(COUNT))}$, and all problems in $\mathsf{Q(FO(COUNT))}$ can be expressed as an SQL query.)

Based on this result, from theoretical point of view, there are many interesting problems that can be solved efficiently but are not expressible in SQL. Therefore an extension of SQL which is still efficient seems interesting. So here is my question:

Is there an extension of SQL (implemented and used in the industry) which captures $\mathsf{P}$ (i.e. can express all polynomial-time computable queries and no others)?

I want a database query language which stisfies all three conditions. It is easy to define an extension which would extend SQL and will capture $\mathsf{P}$. But my questions is if such a language makes sense from the practical perspective, so I want a language that is being used in practice. If this is not the case and there is no such language, then I would like to know if there is a reason that makes such a language uninteresting from the practical viewpoint? For example, are the queries that rise in practice usually simple enough that there is no need for such a language?

Post Reopened by Stéphane Gimenez, sepp2k, Raphael, Dave Clarke, Gilles 'SO- stop being evil'
clarification following the comment thread
Source Link

According to Immerman, the complexity class associated with SQL queries is exactly the class of safe queries in $\mathsf{Q(FO(COUNT))}$ (first-order queries plus counting operator): SQL captures safe queries. (In other words, all SQL queries have a complexity in $\mathsf{Q(FO(COUNT))}$, and all problems in $\mathsf{Q(FO(COUNT))}$ can be expressed as an SQL query.)

Is there an extension of SQL (implemented and used in the industry) which captures $\mathsf{P}$,, i.e. that can express all polynomial time-time computable queries (andand no others)? 

If there isn't, is there a reason? Are the queries that are needed in practice usually simple enough that there is no need for a stronger language?

According to Immerman, the complexity class associated with SQL queries is exactly the class of safe queries in $\mathsf{Q(FO(COUNT))}$ (first-order queries plus counting operator).

Is there an extension of SQL (implemented and used in the industry) which captures polynomial time computable queries (and no others)? If there isn't, is there a reason? Are the queries that are needed in practice usually simple enough that there is no need for a stronger language?

According to Immerman, the complexity class associated with SQL queries is exactly the class of safe queries in $\mathsf{Q(FO(COUNT))}$ (first-order queries plus counting operator): SQL captures safe queries. (In other words, all SQL queries have a complexity in $\mathsf{Q(FO(COUNT))}$, and all problems in $\mathsf{Q(FO(COUNT))}$ can be expressed as an SQL query.)

Is there an extension of SQL (implemented and used in the industry) which captures $\mathsf{P}$,, i.e. that can express all polynomial-time computable queries and no others? 

If there isn't, is there a reason? Are the queries that are needed in practice usually simple enough that there is no need for a stronger language?

adding a clarifying remark regarding the meaning of "captures"
Source Link
Raphael
  • 72.9k
  • 30
  • 181
  • 393

According to Immerman, the complexity class associated with SQL queries is exactly the class of safe queries in $\mathsf{Q(FO(COUNT))}$ (first-order queries plus counting operator).

Is there an extension of SQL (implemented and used in the industry) which captures polynomial time computable queries (and no others)? If there isn't, is there a reason? Are the queries that are needed in practice usually simple enough that there is no need for a stronger language?

According to Immerman, the complexity class associated with SQL queries is exactly the class of safe queries in $\mathsf{Q(FO(COUNT))}$ (first-order queries plus counting operator).

Is there an extension of SQL (implemented and used in the industry) which captures polynomial time computable queries? If there isn't, is there a reason? Are the queries that are needed in practice usually simple enough that there is no need for a stronger language?

According to Immerman, the complexity class associated with SQL queries is exactly the class of safe queries in $\mathsf{Q(FO(COUNT))}$ (first-order queries plus counting operator).

Is there an extension of SQL (implemented and used in the industry) which captures polynomial time computable queries (and no others)? If there isn't, is there a reason? Are the queries that are needed in practice usually simple enough that there is no need for a stronger language?

Post Closed as "not a real question" by user20, Rebecca Chernoff
added 208 characters in body
Source Link
Kaveh
  • 22.5k
  • 4
  • 52
  • 112
Loading
Source Link
Kaveh
  • 22.5k
  • 4
  • 52
  • 112
Loading