Merge lp:~zorba-coders/zorba/bug1064978 into lp:zorba

[Juan Zacarias]

Implementation of features requested in bug1064978 xqxq: add new bind-variable signature
* Added to the DynamicContext API getVariableType function.
* Added xqxq module function xqxq:variable-type.
* Added xqxq module function xqxq:set-variable.

Implementation of features requested in bug1064978 xqxq: add new bind-variable signature
* Added to the DynamicContext API getVariableType function.
* Added xqxq module function xqxq:variable-type.
* Added xqxq module function xqxq:set-variable.

[Juan Zacarias (juan457)]

This is a proposal for solving the requested issue with current bind-variables.

This new function called xqxq:set-variable($query-key as xs:anyURI, $var-name as xs:QName, $value as xs:string*)

fulfills the requested feature of casting an xs:string to the corresponding type of a defined external variable.
To be able to create this function a new function to the DynamicContext API had to be added, the function is called getValueType which returns a string of the type a given variable QName.
And then bringing this function to the xqxq module with the name xqxq:variable-type.

I am not sure about the name set-variable since is different from bind-variable. Would appreciate suggestions on how to name this new function.

[Chris Hillery (ceejatec)]

1. Need some test cases of this functionality, including error conditions, for both new functions.

2. For the element() case, I think you should use the x:parse() function in the built-in XML module (http://www.zorba-xquery.com/modules/xml) with the "parse-external-parsed-entity" option. I'm not sure it'll make a difference, honestly, but it's slightly more correct.

3. I agree set-variable() isn't a great name. It should be more explicit that it is doing casting. Maybe bind-cast-variable() ?

4. It'd be nice if you could support eg. xs:integer+, and all known schema simple types. I have a suggestion - in xqxq:bind-cast-variable(), first check for object/array/element/document-node, and then for any other type, use XQXQ to let XQuery itself do the casting. You'll need to first strip the quantifier from the type string, and then construct a query that does the casting. This should work:

  variable $unquanttype := fn:replace($type, "[*?+]$", "");
  variable $caster := xq := xqxq:prepare-main-module(
     fn:concat("declare variable $val as xs:string* external; ",
               "for $v in $val return $v cast as ",
               $unquanttype));
  xqxq:bind-variable($caster, xs:QName("val"), $value);
  xqxq:evaluate($caster)

The result of that will be the $casted-value. It'd probably be a good idea to explicitly call xqxq:delete-query($caster) also.

review: Needs Fixing

[Juan Zacarias (juan457)]

The changes suggested by Chris have been included can you review again?

[Chris Hillery (ceejatec)]

Looks good!

review: Approve

[Sorin Marian Nasoi (sorin.marian.nasoi)]

review: Approve

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug1064978-2013-04-11T00-04-50.241Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~zorba-coders/zorba/bug1064978 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug1064978-2013-04-11T00-04-50.241Z is finished. The
  final status was:

  184 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Zorba Build Bot (zorba-buildbot)]

Validation queue starting for merge proposal.
Log at: http://zorbatest.lambda.nu:8080/remotequeue/bug1064978-2013-04-11T16-31-07.189Z/log.html

[Zorba Build Bot (zorba-buildbot)]

The attempt to merge lp:~zorba-coders/zorba/bug1064978 into lp:zorba failed. Below is the output from the failed tests.

CMake Error at /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake:275 (message):
  Validation queue job bug1064978-2013-04-11T16-31-07.189Z is finished. The
  final status was:

  184 tests did not succeed - changes not commited.

Error in read script: /home/ceej/zo/testing/zorbatest/tester/TarmacLander.cmake

[Matthias Brantner (matthias-brantner)]

I don't think the bind-cast-variable should go in this module. It's clearly a convenient function that the user can write as well. As such, it would be OK but it adds an XML dependency to the module which is something that we don't want.

review: Needs Fixing

[Matthias Brantner (matthias-brantner)]

From the documentation, it's not clear what format the outType is. Is it a QName, EQName, or even a sequence type? In either case, it should probably be of type Item or a TypeIdentifier.

review: Needs Information

[Juan Zacarias (juan457)]

So, should I remove the xml dependency from the function? or should I remove the whole function?
If we remove the function the user should be able to create the same function by themselves using xqxq:get-type-variable
I will make the changes to getVariableType so it returns a TypeIdentifier or Item and make the documentation clearer.

[Matthias Brantner (matthias-brantner)]

> So, should I remove the xml dependency from the function? or should I remove
> the whole function?
> If we remove the function the user should be able to create the same function
> by themselves using xqxq:get-type-variable
I think we should remove the entire function. It leaves to many unanswered questions. For example,
what if the user wants to pass other parameters to the parse-fragment function or what if the user wants to validate items before passing them as arguments?

[lp:~zorba-coders/zorba/bug1064978]

11264. By Juan Zacarias on 2013-04-23

Changed implementation of Dynamic context function getVariableType to return an Item instead of a zorba::String, also updated function Documentation to make clear what it returns.

11265. By Juan Zacarias on 2013-04-23

Removed Implementation of xqxq function bind-cast-variable

[Juan Zacarias (juan457)]

> > So, should I remove the xml dependency from the function? or should I remove
> > the whole function?
> > If we remove the function the user should be able to create the same
> function
> > by themselves using xqxq:get-type-variable
> I think we should remove the entire function. It leaves to many unanswered
> questions. For example,
> what if the user wants to pass other parameters to the parse-fragment function
> or what if the user wants to validate items before passing them as arguments?

So I made the following changes:
*Removed the implementation of bind-cast-variable
*Changed the return value of getVariableType from zorba::String to a string Item since if the function returns a TypeIdentifier getting a legible type of the variable is lost, unless there is a way to get the schema String from a typeIdentifier?

[Matthias Brantner (matthias-brantner)]

> > > So, should I remove the xml dependency from the function? or should I
> remove
> > > the whole function?
> > > If we remove the function the user should be able to create the same
> > function
> > > by themselves using xqxq:get-type-variable
> > I think we should remove the entire function. It leaves to many unanswered
> > questions. For example,
> > what if the user wants to pass other parameters to the parse-fragment
> function
> > or what if the user wants to validate items before passing them as
> arguments?
>
> So I made the following changes:
> *Removed the implementation of bind-cast-variable
> *Changed the return value of getVariableType from zorba::String to a string
> Item since if the function returns a TypeIdentifier getting a legible type of
> the variable is lost, unless there is a way to get the schema String from a
> typeIdentifier?
I think a string item doesn't make a difference. The type of a variable is a sequence type that consists of a QName and an occurrence indicator. Just having the name doesn't really help. What do you think is missing from the TypeIdentifier? It allows you to retrieve the URI, local name, and quantifier. What am I missing?

[Juan Zacarias (juan457)]

> > > > So, should I remove the xml dependency from the function? or should I
> > remove
> > > > the whole function?
> > > > If we remove the function the user should be able to create the same
> > > function
> > > > by themselves using xqxq:get-type-variable
> > > I think we should remove the entire function. It leaves to many unanswered
> > > questions. For example,
> > > what if the user wants to pass other parameters to the parse-fragment
> > function
> > > or what if the user wants to validate items before passing them as
> > arguments?
> >
> > So I made the following changes:
> > *Removed the implementation of bind-cast-variable
> > *Changed the return value of getVariableType from zorba::String to a string
> > Item since if the function returns a TypeIdentifier getting a legible type
> of
> > the variable is lost, unless there is a way to get the schema String from a
> > typeIdentifier?
> I think a string item doesn't make a difference. The type of a variable is a
> sequence type that consists of a QName and an occurrence indicator. Just
> having the name doesn't really help. What do you think is missing from the
> TypeIdentifier? It allows you to retrieve the URI, local name, and quantifier.
> What am I missing?

There are 2 things I miss information about typeIdentifier:
1. how to create a TypeIdentifier from a XQType
2. The function of xqxq is supposed to return the string of type function so getVariableType is returning the XQType toSchemaString so that the user can actually use it to cast the values of the variable, now does a typeIdentifier has a value like that? Does the localname represents that?

[Matthias Brantner (matthias-brantner)]

> > > > > So, should I remove the xml dependency from the function? or should I
> > > remove
> > > > > the whole function?
> > > > > If we remove the function the user should be able to create the same
> > > > function
> > > > > by themselves using xqxq:get-type-variable
> > > > I think we should remove the entire function. It leaves to many
> unanswered
> > > > questions. For example,
> > > > what if the user wants to pass other parameters to the parse-fragment
> > > function
> > > > or what if the user wants to validate items before passing them as
> > > arguments?
> > >
> > > So I made the following changes:
> > > *Removed the implementation of bind-cast-variable
> > > *Changed the return value of getVariableType from zorba::String to a
> string
> > > Item since if the function returns a TypeIdentifier getting a legible type
> > of
> > > the variable is lost, unless there is a way to get the schema String from
> a
> > > typeIdentifier?
> > I think a string item doesn't make a difference. The type of a variable is a
> > sequence type that consists of a QName and an occurrence indicator. Just
> > having the name doesn't really help. What do you think is missing from the
> > TypeIdentifier? It allows you to retrieve the URI, local name, and
> quantifier.
> > What am I missing?
>
> There are 2 things I miss information about typeIdentifier:
> 1. how to create a TypeIdentifier from a XQType
Take a look at CollectionImpl::getType in src/api/collectionimpl.cpp.

> 2. The function of xqxq is supposed to return the string of type function so
> getVariableType is returning the XQType toSchemaString so that the user can
> actually use it to cast the values of the variable, now does a typeIdentifier
> has a value like that? Does the localname represents that?
The problem is that there is no representation of types in the data model. To answer the question we need to investigate the use case. I think the function should either (1) return a QName item that represents the name of the type (maybe renaming the function to getVariablePrimeType) or (2) return a string using the sequence-type syntax (e.g. xs:string*, xs:integer?, or Q{http://foo.bar}my-type*).

[Juan Zacarias (juan457)]

> > > > > > So, should I remove the xml dependency from the function? or should
> I
> > > > remove
> > > > > > the whole function?
> > > > > > If we remove the function the user should be able to create the same
> > > > > function
> > > > > > by themselves using xqxq:get-type-variable
> > > > > I think we should remove the entire function. It leaves to many
> > unanswered
> > > > > questions. For example,
> > > > > what if the user wants to pass other parameters to the parse-fragment
> > > > function
> > > > > or what if the user wants to validate items before passing them as
> > > > arguments?
> > > >
> > > > So I made the following changes:
> > > > *Removed the implementation of bind-cast-variable
> > > > *Changed the return value of getVariableType from zorba::String to a
> > string
> > > > Item since if the function returns a TypeIdentifier getting a legible
> type
> > > of
> > > > the variable is lost, unless there is a way to get the schema String
> from
> > a
> > > > typeIdentifier?
> > > I think a string item doesn't make a difference. The type of a variable is
> a
> > > sequence type that consists of a QName and an occurrence indicator. Just
> > > having the name doesn't really help. What do you think is missing from the
> > > TypeIdentifier? It allows you to retrieve the URI, local name, and
> > quantifier.
> > > What am I missing?
> >
> > There are 2 things I miss information about typeIdentifier:
> > 1. how to create a TypeIdentifier from a XQType
> Take a look at CollectionImpl::getType in src/api/collectionimpl.cpp.
>
> > 2. The function of xqxq is supposed to return the string of type function so
> > getVariableType is returning the XQType toSchemaString so that the user can
> > actually use it to cast the values of the variable, now does a
> typeIdentifier
> > has a value like that? Does the localname represents that?
> The problem is that there is no representation of types in the data model. To
> answer the question we need to investigate the use case. I think the function
> should either (1) return a QName item that represents the name of the type
> (maybe renaming the function to getVariablePrimeType) or (2) return a string
> using the sequence-type syntax (e.g. xs:string*, xs:integer?, or
> Q{http://foo.bar}my-type*).

As for the purpose of the function, is to allow the user a tool so he can cast a string value into the corresponding type of external variable, that's why we need the function to return something logical in string which in this case the schema string of the type fits perfectly, so an actual type representation of the function is not that helpful if is not usable to cast the variable.

So let me see if I understand your points the first one, is to rename the function (which is appropriate) and to instead of returning the string item with the value turn it into a QName my only question would be the namespace of this QName should it be the same of the external variable? or a new namespace referring to this primetype, also I am guessing that the localname would be the schema string of the type.
As for your second suggestion I don't understand what you mean by it, are you talking about the xqxq.xq description o...

[Matthias Brantner (matthias-brantner)]

> > > > > > > So, should I remove the xml dependency from the function? or
> should
> > I
> > > > > remove
> > > > > > > the whole function?
> > > > > > > If we remove the function the user should be able to create the
> same
> > > > > > function
> > > > > > > by themselves using xqxq:get-type-variable
> > > > > > I think we should remove the entire function. It leaves to many
> > > unanswered
> > > > > > questions. For example,
> > > > > > what if the user wants to pass other parameters to the parse-
> fragment
> > > > > function
> > > > > > or what if the user wants to validate items before passing them as
> > > > > arguments?
> > > > >
> > > > > So I made the following changes:
> > > > > *Removed the implementation of bind-cast-variable
> > > > > *Changed the return value of getVariableType from zorba::String to a
> > > string
> > > > > Item since if the function returns a TypeIdentifier getting a legible
> > type
> > > > of
> > > > > the variable is lost, unless there is a way to get the schema String
> > from
> > > a
> > > > > typeIdentifier?
> > > > I think a string item doesn't make a difference. The type of a variable
> is
> > a
> > > > sequence type that consists of a QName and an occurrence indicator. Just
> > > > having the name doesn't really help. What do you think is missing from
> the
> > > > TypeIdentifier? It allows you to retrieve the URI, local name, and
> > > quantifier.
> > > > What am I missing?
> > >
> > > There are 2 things I miss information about typeIdentifier:
> > > 1. how to create a TypeIdentifier from a XQType
> > Take a look at CollectionImpl::getType in src/api/collectionimpl.cpp.
> >
> > > 2. The function of xqxq is supposed to return the string of type function
> so
> > > getVariableType is returning the XQType toSchemaString so that the user
> can
> > > actually use it to cast the values of the variable, now does a
> > typeIdentifier
> > > has a value like that? Does the localname represents that?
> > The problem is that there is no representation of types in the data model.
> To
> > answer the question we need to investigate the use case. I think the
> function
> > should either (1) return a QName item that represents the name of the type
> > (maybe renaming the function to getVariablePrimeType) or (2) return a string
> > using the sequence-type syntax (e.g. xs:string*, xs:integer?, or
> > Q{http://foo.bar}my-type*).
>
> As for the purpose of the function, is to allow the user a tool so he can cast
> a string value into the corresponding type of external variable, that's why we
> need the function to return something logical in string which in this case the
> schema string of the type fits perfectly, so an actual type representation of
> the function is not that helpful if is not usable to cast the variable.
>
> So let me see if I understand your points the first one, is to rename the
> function (which is appropriate) and to instead of returning the string item
> with the value turn it into a QName my only question would be the namespace of
> this QName should it be the same of the external variable? or a new namespace
> referring to this primetype, also I am guessing that the localname would be
> the sc...

[Matthias Brantner (matthias-brantner)]

I talked to Markos and there are some more issues here.

1. The function should probably go into the static context instead of the dynamic context.
2. It really depends on what you want to cast to. In general, the target type for casting is a sequence type (e.g. node()*, or xs:string?). As already mentioned, this cannot be returned as an item other than a string. If you did that, it pushes a lot of effort to the consumer because he needs to parse the sequence-type. There are two alternatives:
  - xqxq:variable-type-name($name as xs:QName) as xs:QName? which returns the name of type (e.g. no node()*)
  - xqxq:variable-sequence-type($name as xs:QName) as xs:string? which returns the sequence type as a string.

It really depends on exactly what the user needs. I would go with variable-type-name if that's sufficient for all FOTS use cases.

[Juan Zacarias (juan457)]

> I talked to Markos and there are some more issues here.
>
> 1. The function should probably go into the static context instead of the
> dynamic context.
But the Static context doesn't have functions to access the external variables, so if this function is to be implemented in the static context it would actually be using several functions of the dynamic context to work. Since the external variable are part of the Dynamic context isn't it better to just leave them there?

> 2. It really depends on what you want to cast to. In general, the target type
> for casting is a sequence type (e.g. node()*, or xs:string?). As already
> mentioned, this cannot be returned as an item other than a string. If you did
> that, it pushes a lot of effort to the consumer because he needs to parse the
> sequence-type. There are two alternatives:
> - xqxq:variable-type-name($name as xs:QName) as xs:QName? which returns the
> name of type (e.g. no node()*)
> - xqxq:variable-sequence-type($name as xs:QName) as xs:string? which returns
> the sequence type as a string.
>
> It really depends on exactly what the user needs. I would go with variable-
> type-name if that's sufficient for all FOTS use cases.
I will go ahead and make the change for it to return of a QName

[Matthias Brantner (matthias-brantner)]

> > I talked to Markos and there are some more issues here.
> >
> > 1. The function should probably go into the static context instead of the
> > dynamic context.
> But the Static context doesn't have functions to access the external
> variables, so if this function is to be implemented in the static context it
> would actually be using several functions of the dynamic context to work.
> Since the external variable are part of the Dynamic context isn't it better to
> just leave them there?
As I said, it doesn't belong there. If you want to have it in the dynamic context
you should only invoke it after execution.
I think you should use VarInfo* lookup_var(const store::Item* qname) const;
VarInfo contains the type of the variable.

>
> > 2. It really depends on what you want to cast to. In general, the target
> type
> > for casting is a sequence type (e.g. node()*, or xs:string?). As already
> > mentioned, this cannot be returned as an item other than a string. If you
> did
> > that, it pushes a lot of effort to the consumer because he needs to parse
> the
> > sequence-type. There are two alternatives:
> > - xqxq:variable-type-name($name as xs:QName) as xs:QName? which returns
> the
> > name of type (e.g. no node()*)
> > - xqxq:variable-sequence-type($name as xs:QName) as xs:string? which
> returns
> > the sequence type as a string.
> >
> > It really depends on exactly what the user needs. I would go with variable-
> > type-name if that's sufficient for all FOTS use cases.
> I will go ahead and make the change for it to return of a QName
Double check with Sorin whether he really doesn't need the occurrence indicator for casting.

[lp:~zorba-coders/zorba/bug1064978]

11266. By Juan Zacarias on 2013-04-25

Renamed DynamicContext Function getVariableType to getVariablePrimeType it also returns a QName Item now.
XQXQ function xqxq:variable-type renamed to xqxq:variable-type-name it also returns a xs:QName.

[Juan Zacarias (juan457)]

> > > I talked to Markos and there are some more issues here.
> > >
> > > 1. The function should probably go into the static context instead of the
> > > dynamic context.
> > But the Static context doesn't have functions to access the external
> > variables, so if this function is to be implemented in the static context it
> > would actually be using several functions of the dynamic context to work.
> > Since the external variable are part of the Dynamic context isn't it better
> to
> > just leave them there?
> As I said, it doesn't belong there. If you want to have it in the dynamic
> context
> you should only invoke it after execution.
> I think you should use VarInfo* lookup_var(const store::Item* qname) const;
> VarInfo contains the type of the variable.
Oh that makes sense I will make it static context then.

>
> >
> > > 2. It really depends on what you want to cast to. In general, the target
> > type
> > > for casting is a sequence type (e.g. node()*, or xs:string?). As already
> > > mentioned, this cannot be returned as an item other than a string. If you
> > did
> > > that, it pushes a lot of effort to the consumer because he needs to parse
> > the
> > > sequence-type. There are two alternatives:
> > > - xqxq:variable-type-name($name as xs:QName) as xs:QName? which returns
> > the
> > > name of type (e.g. no node()*)
> > > - xqxq:variable-sequence-type($name as xs:QName) as xs:string? which
> > returns
> > > the sequence type as a string.
> > >
> > > It really depends on exactly what the user needs. I would go with
> variable-
> > > type-name if that's sufficient for all FOTS use cases.
> > I will go ahead and make the change for it to return of a QName
> Double check with Sorin whether he really doesn't need the occurrence
> indicator for casting.

The current implementation does return the occurrence indicator

[lp:~zorba-coders/zorba/bug1064978]

11267. By Juan Zacarias on 2013-04-25

Changed DynamicContext getVariablePrimeType Function to the StaticContext.

[Matthias Brantner (matthias-brantner)]

the build doesn't work for me:

/home/mbrantner/zorba/sandbox/src/api/staticcontextimpl.cpp: In member function 'virtual zorba::Item zorba::StaticContextImpl::getVariablePrimeType(const zorba::Item&)':
/home/mbrantner/zorba/sandbox/src/api/staticcontextimpl.cpp:1808:12: error: could not convert 'type' from 'zorba::store::Item_t {aka zorba::store::ItemHandle<zorba::store::Item>}' to 'zorba::Item'

review: Needs Fixing

[Matthias Brantner (matthias-brantner)]

import module namespace xqxq = 'http://www.zorba-xquery.com/modules/xqxq';

variable $queryID := xqxq:prepare-main-module('declare variable $ext2 external; $ext2');

fn:local-name-from-QName(xqxq:variable-type-name($queryID, xs:QName('ext2')))

returns xs:anyType. Shouldn't it be anyType? I think the QName is not constructed
correctly.

xs:anyType should not be a string constant in the code. I think this should come from the typemanager.

review: Needs Fixing

[Matthias Brantner (matthias-brantner)]

> the build doesn't work for me:
>
> /home/mbrantner/zorba/sandbox/src/api/staticcontextimpl.cpp: In member
> function 'virtual zorba::Item
> zorba::StaticContextImpl::getVariablePrimeType(const zorba::Item&)':
> /home/mbrantner/zorba/sandbox/src/api/staticcontextimpl.cpp:1808:12: error:
> could not convert 'type' from 'zorba::store::Item_t {aka
> zorba::store::ItemHandle<zorba::store::Item>}' to 'zorba::Item'

I pushed a fix for the build.

[lp:~zorba-coders/zorba/bug1064978]

11268. By Matthias Brantner on 2013-04-30

fix build on linux

[Matthias Brantner (matthias-brantner)]

import module namespace xqxq = 'http://www.zorba-xquery.com/modules/xqxq';

variable $queryID := xqxq:prepare-main-module('declare variable $ext2 as xs:integer? external; $ext2');

fn:local-name-from-QName(xqxq:variable-type-name($queryID, xs:QName('ext2')))

returns
xs:integer?.

That's not a local-name.

review: Needs Fixing

[Juan Zacarias (juan457)]

> import module namespace xqxq = 'http://www.zorba-xquery.com/modules/xqxq';
>
> variable $queryID := xqxq:prepare-main-module('declare variable $ext2
> external; $ext2');
>
> fn:local-name-from-QName(xqxq:variable-type-name($queryID, xs:QName('ext2')))
>
> returns xs:anyType. Shouldn't it be anyType? I think the QName is not
> constructed
> correctly.
What do you mean is not being constructed correctly?

>
> xs:anyType should not be a string constant in the code. I think this should
> come from the typemanager.
The thing with the variables that doesn't have a type specified in code when asked about the XQType of the variable using the function var->getType it returns a NULL pointer that is why a set a constant value of xs:anyType, now you don't want this to be constant what should I do then? create a new any type XQType variable using the TypeManager and return it's schemaString()?

[lp:~zorba-coders/zorba/bug1064978]

11269. By Juan Zacarias on 2013-04-30

Static Context's getVariablePrimeType function removed constant string return when the requested variable has no type, the value comes now from the typemanager.

[Juan Zacarias (juan457)]

This changes remove the constant return String on xs:anyType it now uses the type manager to create an anyType item type and return it's string value.

With this change the query you mentioned using local-name-from-QName works correctly.

[Matthias Brantner (matthias-brantner)]

Why don't you use XQType::getQName to get the QName directly and return it?

[Juan Zacarias (juan457)]

> Why don't you use XQType::getQName to get the QName directly and return it?
Because if the type is not atomic, if it is an element or an object it throws a zorba exception.

[Sorin Marian Nasoi (sorin.marian.nasoi)]

Please see https://bugs.launchpad.net/zorba/+bug/1064978/comments/9

Unmerged revisions

11269. By Juan Zacarias on 2013-04-30

Static Context's getVariablePrimeType function removed constant string return when the requested variable has no type, the value comes now from the typemanager.

11268. By Matthias Brantner on 2013-04-30

fix build on linux

11267. By Juan Zacarias on 2013-04-25

Changed DynamicContext getVariablePrimeType Function to the StaticContext.

11266. By Juan Zacarias on 2013-04-25

Renamed DynamicContext Function getVariableType to getVariablePrimeType it also returns a QName Item now.
XQXQ function xqxq:variable-type renamed to xqxq:variable-type-name it also returns a xs:QName.

11265. By Juan Zacarias on 2013-04-23

Removed Implementation of xqxq function bind-cast-variable

11264. By Juan Zacarias on 2013-04-23

Changed implementation of Dynamic context function getVariableType to return an Item instead of a zorba::String, also updated function Documentation to make clear what it returns.

11263. By Juan Zacarias on 2013-04-10

Fix for merging with trunk caused errors.

11262. By Juan Zacarias on 2013-04-10

merge with trunk

11261. By Juan Zacarias on 2013-04-10

Added new test for xqxq

11260. By Chris Hillery on 2013-04-10

Removing Windows linefeeds.

=== modified file 'include/zorba/static_context.h'
--- include/zorba/static_context.h	2013-03-25 23:02:19 +0000
+++ include/zorba/static_context.h	2013-04-30 19:07:30 +0000
@@ -813,6 +813,18 @@
    */
   virtual bool
   setDefaultFunctionNamespaces( const std::vector<String>& aURIs ) = 0;
+
+  /** \brief Returns the type of an external variable as a QName. 
+   *
+   * The named external variable may be located in the main query or in any
+   * modules imported directly or indirectly by the query.
+   *
+   * @param the variable's QName
+   * @return the QName of the variable type if it has been retrieved successfully, a NULL Item otherwise.
+   * @throw ZorbaException if an error occured.
+   */
+  virtual Item
+  getVariablePrimeType(const Item& aQName) = 0;
 };
 
 } /* namespace zorba */

=== modified file 'modules/xqxq/xqxq.xq'
--- modules/xqxq/xqxq.xq	2013-04-09 14:22:41 +0000
+++ modules/xqxq/xqxq.xq	2013-04-30 19:07:30 +0000
@@ -285,7 +285,6 @@
 declare %an:sequential function xqxq:bind-variable($query-key as xs:anyURI,
   $var as xs:QName, $value as item()*) as empty-sequence() external ;
 
-
 (:~
  : Evaluates the given prepared query and returns the result
  : of the evaluation. The query must not be sequential or
@@ -387,6 +386,23 @@
   xs:QName) as item()* external;
 
 (:~
+ : This function returns the type of a variable that is bound in the
+ : given query.
+ :
+ : @param $query-key the identifier of a compiled query.
+ : @param $var-name the name of the variable whose value should be returned.
+ :
+ : @return the type of the given variable.
+ :
+ : @error xqxq:NoQueryMatch if no query with the given identifier
+ :   was prepared.
+ : @error xqxq:UndeclaredVariable if the given variable is not declared
+ :   in the query.
+ : @error xqxq:UnboundVariable if the given variable doesn't have a value.
+ :)
+declare function xqxq:variable-type-name($query-key as xs:anyURI, $var-name as 
+  xs:QName) as xs:QName external;                               
+(:~
  : Returns the compiled query identified by the given query-key 
  : as binary data.
  :
@@ -400,8 +416,7 @@
  :)
 declare function xqxq:query-plan($query-key as xs:anyURI) 
   as xs:base64Binary external;
-  
-  
+    
 (:~
  : The function loads a given XQuery program for execution from a 
  : xs:base64Binary query plan, obtained through the xqxq:query-plan function.

=== modified file 'modules/xqxq/xqxq.xq.src/xqxq.cpp'
--- modules/xqxq/xqxq.xq.src/xqxq.cpp	2013-04-15 12:07:41 +0000
+++ modules/xqxq/xqxq.xq.src/xqxq.cpp	2013-04-30 19:07:30 +0000
@@ -85,7 +85,11 @@
     {
       lFunc = new VariableValueFunction(this);
     }
-    else if (localName == "query-plan")
+    else if (localName == "variable-type-name")
+    {
+      lFunc = new VariableTypeFunction(this);
+    }
+	else if (localName == "query-plan")
     {
       lFunc = new QueryPlanFunction(this);
     }
@@ -975,6 +979,48 @@
 /*******************************************************************************
 
 ********************************************************************************/
+zorba::ItemSequence_t VariableTypeFunction::evaluate(
+    const Arguments_t& aArgs,
+    const zorba::StaticContext* aSctx,
+    const zorba::DynamicContext* aDctx) const 
+{
+  String lQueryID = XQXQFunction::getOneStringArgument(aArgs,0);
+
+  QueryMap* lQueryMap;
+  if (!(lQueryMap= dynamic_cast<QueryMap*>(aDctx->getExternalFunctionParameter("xqxqQueryMap"))))
+  {
+    throwError("NoQueryMatch", "String identifying query does not exists.");
+  }
+  
+  XQuery_t lQuery = getQuery(aDctx, lQueryID);
+
+  Item lVarQName = XQXQFunction::getItemArgument(aArgs, 1);
+  zorba::StaticContext* lSctx = const_cast<StaticContext*>(lQuery->getStaticContext());
+  
+  Item lType;
+  try
+  {
+    lType = lSctx->getVariablePrimeType(lVarQName);
+    if(lType.isNull())
+    {
+      std::ostringstream lMsg;
+      lMsg << lVarQName.getLocalName() << ": variable not bound";
+      XQXQFunction::throwError("UndeclaredVariable", lMsg.str());  
+    }
+  }
+  catch (ZorbaException& ze)
+  {
+    if (ze.diagnostic() == zerr::ZAPI0011_VARIABLE_NOT_DECLARED)
+      XQXQFunction::throwError("UndeclaredVariable", ze.what());  
+    throw; // should not happen
+  }
+  return ItemSequence_t(new SingletonItemSequence(lType));
+}
+
+ 
+/*******************************************************************************
+
+********************************************************************************/
 zorba::ItemSequence_t QueryPlanFunction::evaluate(
     const Arguments_t& aArgs,
     const zorba::StaticContext* aSctx,
@@ -999,7 +1045,6 @@
   
   return ItemSequence_t(new SingletonItemSequence(XQXQModule::getItemFactory()->createStreamableBase64Binary(*lExcPlan.release(), &streamReleaser)));
 }
- 
 
 /*******************************************************************************
 

=== modified file 'modules/xqxq/xqxq.xq.src/xqxq.h'
--- modules/xqxq/xqxq.xq.src/xqxq.h	2013-04-15 12:07:41 +0000
+++ modules/xqxq/xqxq.xq.src/xqxq.h	2013-04-30 19:07:30 +0000
@@ -531,38 +531,62 @@
            const zorba::DynamicContext*) const;
 };
 
-  class VariableValueFunction : public XQXQFunction{
-    protected:
-      class ValueItemSequence : public ItemSequence
-      {
-        protected:
-          Iterator_t theIterator;
-
-        public:
-          ValueItemSequence(Iterator_t& aIter)
-            : theIterator(aIter)
-          {
-          }
-
-          virtual ~ValueItemSequence(){}
-
-          Iterator_t
-          getIterator() { return theIterator; }
-
-      };
-    public:
-      VariableValueFunction(const XQXQModule* aModule) : XQXQFunction(aModule) {}
-
-      virtual ~VariableValueFunction() {}
-
-      virtual zorba::String
-        getLocalName() const {return "variable-value"; }
-
-      virtual zorba::ItemSequence_t
-        evaluate(const Arguments_t&,
-                 const zorba::StaticContext*,
-                 const zorba::DynamicContext*) const;
-  };
+
+/*******************************************************************************
+
+********************************************************************************/
+class VariableValueFunction : public XQXQFunction{
+  protected:
+    class ValueItemSequence : public ItemSequence
+    {
+      protected:
+        Iterator_t theIterator;
+
+      public:
+        ValueItemSequence(Iterator_t& aIter)
+          : theIterator(aIter)
+        {
+        }
+
+        virtual ~ValueItemSequence(){}
+
+        Iterator_t
+        getIterator() { return theIterator; }
+
+    };
+  public:
+    VariableValueFunction(const XQXQModule* aModule) : XQXQFunction(aModule) {}
+
+    virtual ~VariableValueFunction() {}
+
+    virtual zorba::String
+      getLocalName() const {return "variable-value"; }
+
+    virtual zorba::ItemSequence_t
+      evaluate(const Arguments_t&,
+                const zorba::StaticContext*,
+                const zorba::DynamicContext*) const;
+};
+
+
+/*******************************************************************************
+
+********************************************************************************/
+class VariableTypeFunction : public XQXQFunction
+{
+public:
+  VariableTypeFunction(const XQXQModule* aModule) : XQXQFunction(aModule) {}
+
+  virtual ~VariableTypeFunction() {}
+
+  virtual zorba::String
+  getLocalName() const {return "variable-type-name"; }
+
+  virtual zorba::ItemSequence_t
+  evaluate(const Arguments_t&,
+           const zorba::StaticContext*,
+           const zorba::DynamicContext*) const;
+};
 
 /*******************************************************************************
 

=== modified file 'src/api/dynamiccontextimpl.cpp'
--- src/api/dynamiccontextimpl.cpp	2013-04-25 20:41:11 +0000
+++ src/api/dynamiccontextimpl.cpp	2013-04-30 19:07:30 +0000
@@ -184,7 +184,6 @@
   return var;
 }
 
-
 /****************************************************************************//**
 
 ********************************************************************************/

=== modified file 'src/api/staticcontextimpl.cpp'
--- src/api/staticcontextimpl.cpp	2013-03-25 23:02:19 +0000
+++ src/api/staticcontextimpl.cpp	2013-04-30 19:07:30 +0000
@@ -1769,5 +1769,51 @@
   }
 }
 
+Item 
+StaticContextImpl::getVariablePrimeType(
+    const Item& aQName)
+{
+  ZORBA_TRY
+  {
+    store::Item_t type;
+
+    store::Item_t lQname = Unmarshaller::getInternalItem(aQName);
+    VarInfo* var = NULL;
+
+    try
+    {
+      var = theCtx->lookup_var(lQname);
+      if (!var)
+        return NULL;
+      const XQType* varType = var->getType();
+      zstring varTypeString;
+      if (!varType)
+      {
+        xqtref_t lAnyType = theCtx->get_typemanager()->create_any_type();
+        varTypeString =  lAnyType->toSchemaString();
+      }
+      else
+        varTypeString = varType->toSchemaString();
+      
+      GENV_ITEMFACTORY->createQName(type, lQname->getNamespace(), zstring(), varTypeString);
+    }
+    catch (ZorbaException const& e)
+    {
+      // Normally, we should be throwing an exception if the variable has not
+      // been declared inside the xquery program, but this cases many failures
+      // with the w3c XQTS.
+      if (e.diagnostic() == err::XPST0008)
+      {
+        return NULL;
+      }
+      throw;
+    }
+    return type.getp();
+  }
+  ZORBA_CATCH
+  return NULL;
+}
+
+
 } /* namespace zorba */
 /* vim:set et sw=2 ts=2: */

=== modified file 'src/api/staticcontextimpl.h'
--- src/api/staticcontextimpl.h	2013-03-25 23:02:19 +0000
+++ src/api/staticcontextimpl.h	2013-04-30 19:07:30 +0000
@@ -332,6 +332,9 @@
 public:
   virtual void
   clearBaseURI();
+  
+  virtual Item 
+  getVariablePrimeType(const Item& aQname);
 
 };
 

=== added file 'test/rbkt/ExpQueryResults/zorba/xqxq/variable-type-name.xml.res'
--- test/rbkt/ExpQueryResults/zorba/xqxq/variable-type-name.xml.res	1970-01-01 00:00:00 +0000
+++ test/rbkt/ExpQueryResults/zorba/xqxq/variable-type-name.xml.res	2013-04-30 19:07:30 +0000
@@ -0,0 +1,1 @@
+xs:integer xs:string xs:dateTime object() element(*, xs:anyType?)
\ No newline at end of file

=== added file 'test/rbkt/Queries/zorba/xqxq/variable-type-name.xq'
--- test/rbkt/Queries/zorba/xqxq/variable-type-name.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/xqxq/variable-type-name.xq	2013-04-30 19:07:30 +0000
@@ -0,0 +1,13 @@
+import module namespace xqxq = 'http://www.zorba-xquery.com/modules/xqxq';
+
+variable $queryID := xqxq:prepare-main-module('declare variable $ext as xs:integer external; $ext');
+variable $queryID2 := xqxq:prepare-main-module('declare variable $ext as xs:string external; $ext');
+variable $queryID3 := xqxq:prepare-main-module('declare variable $ext as xs:dateTime external; $ext');
+variable $queryID4 := xqxq:prepare-main-module('declare variable $ext as object() external; $ext');
+variable $queryID5 := xqxq:prepare-main-module('declare variable $ext as element() external; $ext');
+
+xqxq:variable-type-name($queryID, xs:QName('ext')),
+xqxq:variable-type-name($queryID2, xs:QName('ext')),
+xqxq:variable-type-name($queryID3, xs:QName('ext')),
+xqxq:variable-type-name($queryID4, xs:QName('ext')),
+xqxq:variable-type-name($queryID5, xs:QName('ext'))
\ No newline at end of file

=== added file 'test/rbkt/Queries/zorba/xqxq/variable-type-name2.spec'
--- test/rbkt/Queries/zorba/xqxq/variable-type-name2.spec	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/xqxq/variable-type-name2.spec	2013-04-30 19:07:30 +0000
@@ -0,0 +1,1 @@
+Error: http://www.zorba-xquery.com/modules/xqxq:UndeclaredVariable
\ No newline at end of file

=== added file 'test/rbkt/Queries/zorba/xqxq/variable-type-name2.xq'
--- test/rbkt/Queries/zorba/xqxq/variable-type-name2.xq	1970-01-01 00:00:00 +0000
+++ test/rbkt/Queries/zorba/xqxq/variable-type-name2.xq	2013-04-30 19:07:30 +0000
@@ -0,0 +1,5 @@
+import module namespace xqxq = 'http://www.zorba-xquery.com/modules/xqxq';
+
+variable $queryID := xqxq:prepare-main-module('declare variable $ext as xs:integer external; $ext');
+
+xqxq:variable-type-name($queryID, xs:QName('ext2'))
\ No newline at end of file