A proposal for vector math in ADQLWith tables containing massive amounts of vectors becoming common (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:  
Deleted:  
< <  
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Element Access
To access an element of a vector, write Again in keeping with common SQL practices, accessing elements outside of that range gives NULL.  
Added:  
> >  It is also possible to access to multiple elements of a vector (as a subarray). To access, write [lowerbound:upperbound], where lower and upper bounds are integervalued expressions and are both included. Lowerbound must be equal or greater to 1 due to indexes in ADQL are 1based and if upperbound is greater to the lenght of the array not error is going to be returned.  
Basic Math
Vector computations
Array AggregationThese are functions that work like SQL aggregate functions, just on the elements of arrays. These ought to return the types of the elements of the argument (real, double precision, integers).
Aggregate Functions for ArraysThe following standard ADQL aggregate functions, applied to arrays, work componentwise:
Array Maparr_map(expr_over_x, arr) computes a new array by binding each element of arr to x in turn and then computing expr_over_x. expr_over_x is an ADQL numeric_value_expression that can use column references as usual, except that the name x is reserved for the evaluation. For instance, arr_map(power(10, x), mags) will return an array [power(10, mags[1]), power(10, mags[2]), power(10, mags[3])...]. Admittedly, the artificial "x" here is not pretty. The clean solution would be to define some sort of lambda calculus for ADQL ("first class functions"), but that's almost certainly overdoing it (although: does anyone do that in SQL?). Perhaps it is preferable to use the array name itself, as in arr_map(power(10, mags), mags)? That would at least not clobber other names that SQL might want to use somewhere else? In implementation, at least Markus had to massage these column references on the translator level anyway. On the other hand, one might be tempted then to leave out the second argument at all, and that would require a lot more thought, first, as regards finding arrays in the expression (do we want to require translators to be able to do that?), and then what should happen if there are multiple arrays.  
Added:  
> >  Other array functions  
Added:  
> >  Other functions related with vectors are:
 
Implementation Status  
Changed:  
< <  The SQL part of an implementation of this in postgresql is in DaCHS //adql RD, the create_array_operator script. The functionality can be tried out at the TAP service at http://dc.gvo.org/tap. Suitable tables (i.e., with vectorlike data) include sdssdr16.main, gaia.dr2epochflux, onebigb.ssa, or dfbsspec.spectra.  
> >  The SQL part of an implementation of this in postgresql is in DaCHS //adql RD, the create_array_operator script. The functionality can be tried out at the TAP service at http://dc.gvo.org/tap. Suitable tables (i.e., with vectorlike data) include sdssdr16.main, gaia.dr2epochflux, onebigb.ssa, or dfbsspec.spectra. In this implementation, array multiple access (subarrays) and function arr_in are not implemented.  
Test cases for implementors can be derived from sqlarraytest.py.  
Added:  
> >  This vector proposal has been also implemented at CEFCA as a part of the CEFCA Catalogues Portal. The functionality can be tried at the TAP service of the different projects/data releases offered.  
<
 
Deleted:  
< < 
A proposal for vector math in ADQLWith tables containing massive amounts of vectors becoming common (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Element Access
To access an element of a vector, write Again in keeping with common SQL practices, accessing elements outside of that range gives NULL.
Basic Math
Vector computations
Array AggregationThese are functions that work like SQL aggregate functions, just on the elements of arrays. These ought to return the types of the elements of the argument (real, double precision, integers).
 
Added:  
> > 
 
Aggregate Functions for ArraysThe following standard ADQL aggregate functions, applied to arrays, work componentwise:
 
Changed:  
< <  When aggregates are computed over arrays of different lengths, the result undefined for now. [Options would be erroring out, extending with NaN – i.e., extended items are NaN –, or extending with NULL – i.e., extended items are ignored. Postgres chooses the third option for their MIN and MAX, and it's most straightforward in implementation, so it's also what DaCHS does. But it's not necessarily a good idea].  
> >  When aggregates are computed over arrays of different lengths, the result undefined for now. [Options would be erroring out, extending with NaN – i.e., extended items are NaN –, or extending with NULL – i.e., extended items are ignored. Postgres chooses the third option for their MIN and MAX, and it's most straightforward in implementation, so it's also what DaCHS does. But it's not necessarily a good idea].  
Array Maparr_map(expr_over_x, arr) computes a new array by binding each element of arr to x in turn and then computing expr_over_x. expr_over_x is an ADQL numeric_value_expression that can use column references as usual, except that the name x is reserved for the evaluation. For instance, arr_map(power(10, x), mags) will return an array [power(10, mags[1]), power(10, mags[2]), power(10, mags[3])...]. Admittedly, the artificial "x" here is not pretty. The clean solution would be to define some sort of lambda calculus for ADQL ("first class functions"), but that's almost certainly overdoing it (although: does anyone do that in SQL?). Perhaps it is preferable to use the array name itself, as in arr_map(power(10, mags), mags)? That would at least not clobber other names that SQL might want to use somewhere else? In implementation, at least Markus had to massage these column references on the translator level anyway. On the other hand, one might be tempted then to leave out the second argument at all, and that would require a lot more thought, first, as regards finding arrays in the expression (do we want to require translators to be able to do that?), and then what should happen if there are multiple arrays.
Implementation StatusThe SQL part of an implementation of this in postgresql is in DaCHS //adql RD, the create_array_operator script. The functionality can be tried out at the TAP service at http://dc.gvo.org/tap. Suitable tables (i.e., with vectorlike data) include sdssdr16.main, gaia.dr2epochflux, onebigb.ssa, or dfbsspec.spectra. Test cases for implementors can be derived from sqlarraytest.py.
<
 
Added:  
> > 
A proposal for vector math in ADQLWith tables containing massive amounts of vectors becoming common (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Element Access
To access an element of a vector, write Again in keeping with common SQL practices, accessing elements outside of that range gives NULL.
Basic Math
Vector computations
Array AggregationThese are functions that work like SQL aggregate functions, just on the elements of arrays. These ought to return the types of the elements of the argument (real, double precision, integers).
Aggregate Functions for ArraysThe following standard ADQL aggregate functions, applied to arrays, work componentwise:  
Changed:  
< < 
 
> > 
 
Array Maparr_map(expr_over_x, arr) computes a new array by binding each element of arr to x in turn and then computing expr_over_x. expr_over_x is an ADQL numeric_value_expression that can use column references as usual, except that the name x is reserved for the evaluation. For instance, arr_map(power(10, x), mags) will return an array [power(10, mags[1]), power(10, mags[2]), power(10, mags[3])...]. Admittedly, the artificial "x" here is not pretty. The clean solution would be to define some sort of lambda calculus for ADQL ("first class functions"), but that's almost certainly overdoing it (although: does anyone do that in SQL?). Perhaps it is preferable to use the array name itself, as in arr_map(power(10, mags), mags)? That would at least not clobber other names that SQL might want to use somewhere else? In implementation, at least Markus had to massage these column references on the translator level anyway. On the other hand, one might be tempted then to leave out the second argument at all, and that would require a lot more thought, first, as regards finding arrays in the expression (do we want to require translators to be able to do that?), and then what should happen if there are multiple arrays.
Implementation StatusThe SQL part of an implementation of this in postgresql is in DaCHS //adql RD, the create_array_operator script. The functionality can be tried out at the TAP service at http://dc.gvo.org/tap. Suitable tables (i.e., with vectorlike data) include sdssdr16.main, gaia.dr2epochflux, onebigb.ssa, or dfbsspec.spectra.  
Changed:  
< <  Test cases for implementors can be derived from  
> >  Test cases for implementors can be derived from sqlarraytest.py.  
Deleted:  
< <  sqlarraytest.py.  
<

A proposal for vector math in ADQLWith tables containing massive amounts of vectors becoming common (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Element Access
To access an element of a vector, write Again in keeping with common SQL practices, accessing elements outside of that range gives NULL.
Basic Math  
Changed:  
< < 
 
> > 
 
Vector computations  
Changed:  
< <  * arr_scalprod(vec1,vec2) is the scalar product of two vectors. Where vec1 and vec2 have unequal length, the shorter vector is padded with NaNs to the length of the longer vector. That is, the scalar product of vectors of unequal length is NaN.  
> > 
 
Array AggregationThese are functions that work like SQL aggregate functions, just on the elements of arrays. These ought to return the types of the elements of the argument (real, double precision, integers).
Aggregate Functions for ArraysThe following standard ADQL aggregate functions, applied to arrays, work componentwise:
 
Changed:  
< <  When aggregates are computed over arrays of different lengths, the result undefined for now. [Options would be erroring out, extending with NaN – i.e., extended items are NaN –, or extending with NULL – i.e., extended items are ignored. Postgres chooses the third option for their MIN and MAX, and it's most straightforward in implementation, so it's also what DaCHS does. But it's not necessarily a good idea].  
> >  When aggregates are computed over arrays of different lengths, the result undefined for now. [Options would be erroring out, extending with NaN – i.e., extended items are NaN –, or extending with NULL – i.e., extended items are ignored. Postgres chooses the third option for their MIN and MAX, and it's most straightforward in implementation, so it's also what DaCHS does. But it's not necessarily a good idea].  
Array Maparr_map(expr_over_x, arr) computes a new array by binding each element of arr to x in turn and then computing expr_over_x. expr_over_x is an ADQL numeric_value_expression that can use column references as usual, except that the name x is reserved for the evaluation. For instance, arr_map(power(10, x), mags) will return an array [power(10, mags[1]), power(10, mags[2]), power(10, mags[3])...]. Admittedly, the artificial "x" here is not pretty. The clean solution would be to define some sort of lambda calculus for ADQL ("first class functions"), but that's almost certainly overdoing it (although: does anyone do that in SQL?). Perhaps it is preferable to use the array name itself, as in arr_map(power(10, mags), mags)? That would at least not clobber other names that SQL might want to use somewhere else? In implementation, at least Markus had to massage these column references on the translator level anyway. On the other hand, one might be tempted then to leave out the second argument at all, and that would require a lot more thought, first, as regards finding arrays in the expression (do we want to require translators to be able to do that?), and then what should happen if there are multiple arrays.
Implementation StatusThe SQL part of an implementation of this in postgresql is in DaCHS //adql RD, the create_array_operator script. The functionality can be tried out at the TAP service at http://dc.gvo.org/tap. Suitable tables (i.e., with vectorlike data) include sdssdr16.main, gaia.dr2epochflux, onebigb.ssa, or dfbsspec.spectra.  
Added:  
> >  Test cases for implementors can be derived from sqlarraytest.py.  
<

A proposal for vector math in ADQLWith tables containing massive amounts of vectors becoming common (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Element Access
To access an element of a vector, write Again in keeping with common SQL practices, accessing elements outside of that range gives NULL.
Basic Math
 
Changed:  
< < 
 
> > 
 
Vector computations* arr_scalprod(vec1,vec2) is the scalar product of two vectors. Where vec1 and vec2 have unequal length, the shorter vector is padded with NaNs to the length of the longer vector. That is, the scalar product of vectors of unequal length is NaN.
Array AggregationThese are functions that work like SQL aggregate functions, just on the elements of arrays. These ought to return the types of the elements of the argument (real, double precision, integers).
Aggregate Functions for ArraysThe following standard ADQL aggregate functions, applied to arrays, work componentwise:
 
Deleted:  
< <  
Array Map  
Changed:  
< <  arr_map(expr_over_x, arr) computes a new array by binding each element  
> >  arr_map(expr_over_x, arr) computes a new array by binding each element of arr to x in turn and then computing expr_over_x.  
Deleted:  
< <  of arr to x in turn and then computing expr_over_x.  
Changed:  
< <  expr_over_x is an ADQL numeric_value_expression that can use column  
> >  expr_over_x is an ADQL numeric_value_expression that can use column references as usual, except that the name x is reserved for the evaluation.  
Deleted:  
< <  references as usual, except that the name x is reserved for the evaluation.  
Changed:  
< <  For instance, arr_map(power(10, x), mags) will return an array  
> >  For instance, arr_map(power(10, x), mags) will return an array [power(10, mags[1]), power(10, mags[2]), power(10, mags[3])...].  
Deleted:  
< <  [power(10, mags[1]), power(10, mags[2]), power(10, mags[3])...].  
Changed:  
< <  Admittedly, the artificial "x" here is not pretty. The clean solution  
> >  Admittedly, the artificial "x" here is not pretty. The clean solution would be to define some sort of lambda calculus for ADQL ("first class functions"), but that's almost certainly overdoing it (although: does anyone do that in SQL?).  
Deleted:  
< <  would be to define some sort of lambda calculus for ADQL ("first class functions"), but that's almost certainly overdoing it (although: does anyone do that in SQL?).  
Changed:  
< <  Perhaps it is preferable to use the array name itself, as in  
> >  Perhaps it is preferable to use the array name itself, as in arr_map(power(10, mags), mags)? That would at least not clobber other names that SQL might want to use somewhere else? In implementation, at least Markus had to massage these column references on the translator level anyway. On the other hand, one might be tempted then to leave out the second argument at all, and that would require a lot more thought, first, as regards finding arrays in the expression (do we want to require translators to be able to do that?), and then what should happen if there are multiple arrays.  
Deleted:  
< <  arr_map(power(10, mags), mags)? That would at least not clobber other names that SQL might want to use somewhere else? In implementation, at least Markus had to massage these column references on the translator level anyway. On the other hand, one might be tempted then to leave out the second argument at all, and that would require a lot more thought, first, as regards finding arrays in the expression (do we want to require translators to be able to do that?), and then what should happend if there are multiple arrays.  
Implementation StatusThe SQL part of an implementation of this in postgresql is in DaCHS //adql RD, the create_array_operator script. The functionality can be tried out at the TAP service at http://dc.gvo.org/tap. Suitable tables (i.e., with vectorlike data) include sdssdr16.main, gaia.dr2epochflux, onebigb.ssa, or dfbsspec.spectra.
<

A proposal for vector math in ADQLWith tables containing massive amounts of vectors becoming common (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Element Access
To access an element of a vector, write Again in keeping with common SQL practices, accessing elements outside of that range gives NULL.
Basic Math
Vector computations  
Changed:  
< <  * arr_scalprod(vec1,vec2) is the scalar product of two vectors. Where vec1 and vec2 have unequal length, the shorter vector is padded with NaNs to the length of the longer vector. That is, the scalar product of vectors of unequal length is NaN.  
> >  * arr_scalprod(vec1,vec2) is the scalar product of two vectors. Where vec1 and vec2 have unequal length, the shorter vector is padded with NaNs to the length of the longer vector. That is, the scalar product of vectors of unequal length is NaN.  
Array AggregationThese are functions that work like SQL aggregate functions, just on the elements of arrays. These ought to return the types of the elements of the argument (real, double precision, integers).
Aggregate Functions for ArraysThe following standard ADQL aggregate functions, applied to arrays, work componentwise:
 
Deleted:  
< <  
When aggregates are computed over arrays of different lengths, the result undefined for now. [Options would be erroring out, extending with NaN – i.e., extended items are NaN –, or extending with NULL – i.e., extended items are ignored. Postgres chooses the third option for their MIN and MAX, and it's most straightforward in implementation, so it's also what DaCHS does. But it's not necessarily a good idea].  
Deleted:  
< <  Implementation Status  
Changed:  
< <  The SQL part of an implementation of this in postgresql is in DaCHS //adql RD, the create_array_operator script. The functionality can be tried out at the TAP service at http://dc.gvo.org/tap. Suitable tables (i.e., with vectorlike data) include sdssdr16.main, gaia.dr2epochflux, onebigb.ssa, or dfbsspec.spectra.  
> >  Array Map  
Added:  
> >  arr_map(expr_over_x, arr) computes a new array by binding each element
of arr to x in turn and then computing expr_over_x.
expr_over_x is an ADQL numeric_value_expression that can use column references as usual, except that the name x is reserved for the evaluation. For instance, arr_map(power(10, x), mags) will return an array [power(10, mags[1]), power(10, mags[2]), power(10, mags[3])...]. Admittedly, the artificial "x" here is not pretty. The clean solution would be to define some sort of lambda calculus for ADQL ("first class functions"), but that's almost certainly overdoing it (although: does anyone do that in SQL?). Perhaps it is preferable to use the array name itself, as in arr_map(power(10, mags), mags)? That would at least not clobber other names that SQL might want to use somewhere else? In implementation, at least Markus had to massage these column references on the translator level anyway. On the other hand, one might be tempted then to leave out the second argument at all, and that would require a lot more thought, first, as regards finding arrays in the expression (do we want to require translators to be able to do that?), and then what should happend if there are multiple arrays.
Implementation StatusThe SQL part of an implementation of this in postgresql is in DaCHS //adql RD, the create_array_operator script. The functionality can be tried out at the TAP service at http://dc.gvo.org/tap. Suitable tables (i.e., with vectorlike data) include sdssdr16.main, gaia.dr2epochflux, onebigb.ssa, or dfbsspec.spectra.  
<

A proposal for vector math in ADQLWith tables containing massive amounts of vectors becoming common (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Element Access
To access an element of a vector, write Again in keeping with common SQL practices, accessing elements outside of that range gives NULL.
Basic Math
 
Changed:  
< <  
> > 
 
Added:  
> > 
 
 
Added:  
> >  Vector computations* arr_scalprod(vec1,vec2) is the scalar product of two vectors. Where vec1 and vec2 have unequal length, the shorter vector is padded with NaNs to the length of the longer vector. That is, the scalar product of vectors of unequal length is NaN.  
Array AggregationThese are functions that work like SQL aggregate functions, just on the elements of arrays. These ought to return the types of the elements of the argument (real, double precision, integers).
 
Deleted:  
< < 
 
Aggregate Functions for ArraysThe following standard ADQL aggregate functions, applied to arrays, work componentwise:
 
Deleted:  
< < 
 
 
Changed:  
< <  When aggregates are computed over arrays of different lengths, the result undefined for now. [Options would be erroring out, extending with NaN – i.e., extended items are NaN –, or extending with NULL – i.e., extended items are ignored. Postgres chooses the third option for their MIN and MAX, and it's most straightforward in implementation, so it's also what DaCHS does. But it's not necessarily a good idea].  
> >  When aggregates are computed over arrays of different lengths, the result undefined for now. [Options would be erroring out, extending with NaN – i.e., extended items are NaN –, or extending with NULL – i.e., extended items are ignored. Postgres chooses the third option for their MIN and MAX, and it's most straightforward in implementation, so it's also what DaCHS does. But it's not necessarily a good idea].
Implementation StatusThe SQL part of an implementation of this in postgresql is in DaCHS //adql RD, the create_array_operator script. The functionality can be tried out at the TAP service at http://dc.gvo.org/tap. Suitable tables (i.e., with vectorlike data) include sdssdr16.main, gaia.dr2epochflux, onebigb.ssa, or dfbsspec.spectra.  
<

A proposal for vector math in ADQLWith tables containing massive amounts of vectors becoming common (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Element Access
To access an element of a vector, write Again in keeping with common SQL practices, accessing elements outside of that range gives NULL.
Basic Math
 
Changed:  
< < 
 
> > 
 
Array AggregationThese are functions that work like SQL aggregate functions, just on the elements of arrays. These ought to return the types of the elements of the argument (real, double precision, integers).
 
Added:  
> > 
Aggregate Functions for ArraysThe following standard ADQL aggregate functions, applied to arrays, work componentwise:
When aggregates are computed over arrays of different lengths, the result undefined for now. [Options would be erroring out, extending with NaN – i.e., extended items are NaN –, or extending with NULL – i.e., extended items are ignored. Postgres chooses the third option for their MIN and MAX, and it's most straightforward in implementation, so it's also what DaCHS does. But it's not necessarily a good idea].  
<

A proposal for vector math in ADQL  
Changed:  
< <  With tables containing massive amounts of vectors (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that.  
> >  With tables containing massive amounts of vectors becoming common (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that.  
TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>  
Added:  
> >  Element Access
To access an element of a vector, write Again in keeping with common SQL practices, accessing elements outside of that range gives NULL.  
Basic Math
 
Changed:  
< <  
> >  
 
Added:  
> > 
Array AggregationThese are functions that work like SQL aggregate functions, just on the elements of arrays. These ought to return the types of the elements of the argument (real, double precision, integers).
 
<

A proposal for vector math in ADQLWith tables containing massive amounts of vectors (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Basic Math  
Changed:  
< < 
 
> > 
 
Added:  
> >  
<

A proposal for vector math in ADQLWith tables containing massive amounts of vectors (e.g., the collections of lowresolution spectra within Gaia DR3 or the Digitised Byurakan Surveys), giving TAP users a toolset to do serverside work with arrays becomes highly desirable and will significantly enhance the power of ADQL to do serverside analyses. This is an attempt to provide a baseline feature set for that. TAP servers supporting this should declare that by defining a language feature. While no IVOA specification exists for array operations, use the VECTORMATH key from GAVO's ADQL extensions standards record, like this:
<languageFeatures type="ivo://org.gavo.dc/std/exts#extraadqlkeywords"> <feature> <form>VECTORMATH</form> <description>You can compute with vectors here. See https://wiki.ivoa.net/twiki/bin/view/IVOA/ADQLVectorMath for an overview of the functions and operators available. </description> </feature> </languageFeatures>
Basic Math
<
