gears/database2/statement.cc - Issue 717: Database2Values, argument conversion implemented

Delta Between Two Patch Sets: gears/database2/statement.cc

Issue 717: Database2Values, argument conversion implemented (Closed) SVN Base: http://google-gears.googlecode.com/svn/contrib/dimitri.glazkov/database2/

Left Patch Set: Created 4 months ago

Right Patch Set: ready for another look. Created 3 months, 3 weeks ago

Use n/p to move between diff chunks; N/P to move between comments. Please Sign in to add in-line comments.

Jump to:

Left: Side by side diff | Download
Right: Side by side diff | Download

LEFT	RIGHT
1 // Copyright 2008, Google Inc.	1 // Copyright 2008, Google Inc.

2 //	2 //

3 // Redistribution and use in source and binary forms, with or without	3 // Redistribution and use in source and binary forms, with or without

4 // modification, are permitted provided that the following conditions are met:	4 // modification, are permitted provided that the following conditions are met:

5 //	5 //

6 // 1. Redistributions of source code must retain the above copyright notice,	6 // 1. Redistributions of source code must retain the above copyright notice,

7 // this list of conditions and the following disclaimer.	7 // this list of conditions and the following disclaimer.

8 // 2. Redistributions in binary form must reproduce the above copyright notice,	8 // 2. Redistributions in binary form must reproduce the above copyright notice,

9 // this list of conditions and the following disclaimer in the documentation	9 // this list of conditions and the following disclaimer in the documentation

10 // and/or other materials provided with the distribution.	10 // and/or other materials provided with the distribution.

11 // 3. Neither the name of Google Inc. nor the names of its contributors may be	11 // 3. Neither the name of Google Inc. nor the names of its contributors may be

12 // used to endorse or promote products derived from this software without	12 // used to endorse or promote products derived from this software without

13 // specific prior written permission.	13 // specific prior written permission.

14 //	14 //

15 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED	15 // THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED

16 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF	16 // WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

17 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO	17 // MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO

18 // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,	18 // EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

19 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,	19 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

20 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;	20 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;

21 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,	21 // OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,

22 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR	22 // WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR

23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF	23 // OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF

24 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	24 // ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

25	25

26 #include "gears/database2/statement.h"	26 #include "gears/database2/statement.h"

27	27

28 #include "gears/database2/transaction.h"	28 #include "gears/database2/transaction.h"

29	29

30 void Database2Statement::InvokeCallback(Database2Transaction *tx) {	30 void Database2Statement::InvokeCallback(Database2Transaction *tx) {

31 // for now, just return the Database2Statement	31 // for now, just return the Database2Statement

32 JsParamToSend send_argv[] = {	32 JsParamToSend send_argv[] = {

33 { JSPARAM_STRING16, &sql_statement_ }	33 { JSPARAM_STRING16, &sql_statement_ }

34 };	34 };

35	35

36 if (HasCallback()) {	36 if (HasCallback()) {

37 tx->GetJsRunner()->InvokeCallback(callback_.get(), ARRAYSIZE(send_argv),	37 tx->GetJsRunner()->InvokeCallback(callback_.get(), ARRAYSIZE(send_argv),

38 send_argv, NULL);	38 send_argv, NULL);

39 }	39 }

40 }	40 }

41	41

42 void Database2Statement::InvokeErrorCallback(Database2Transaction *tx,	42 void Database2Statement::InvokeErrorCallback(Database2Transaction *tx,

43 JsObject *error) {	43 JsObject *error) {

44 }	44 }

45	45

46 bool Database2Statement::Create(const std::string16 &sql_statement,	46 bool Database2Statement::Create(const std::string16 &sql_statement,

47 const JsArray &sql_arguments,	47 JsArray *sql_arguments,

48 JsRootedCallback *callback,	48 JsRootedCallback *callback,

49 JsRootedCallback *error_callback,	49 JsRootedCallback *error_callback,

50 Database2Statement **instance) {	50 Database2Statement **instance) {

51 scoped_ptr<Database2Statement> statement;	51 scoped_ptr<Database2Statement> statement(new Database2Statement());

52 statement.reset(new Database2Statement());	52

	53 // NULL should be passed if no arguments are specified

	54 assert(!sql_arguments \|\| !JsTokenIsNullOrUndefined(sql_arguments->token()));

	55 // NULL should be passed if a callback is not specified

	56 assert(!callback \|\| !JsTokenIsNullOrUndefined(callback->token()));

	57 assert(!error_callback \|\| !JsTokenIsNullOrUndefined(error_callback->token()));

	58

53 statement->sql_statement_.assign(sql_statement);	59 statement->sql_statement_.assign(sql_statement);

54 statement->callback_.reset(callback);	60 statement->callback_.reset(callback);

55 statement->error_callback_.reset(error_callback);	61 statement->error_callback_.reset(error_callback);

56	62

57 Database2Values *arguments;	63 Database2Values *arguments;

58 if (!Database2Values::CreateFromJsArray(sql_arguments, &arguments)) {	64 if (!Database2Values::CreateFromJsArray(sql_arguments, &arguments)) {

59 return false;	65 return false;

60 }	66 }

61	67

62 statement->arguments_.reset(arguments);	68 statement->arguments_.reset(arguments);

63	69

64 *instance = statement.release();	70 *instance = statement.release();

65 return true;	71 return true;

66 }	72 }

67	73

68 // static	74 // static

69 bool Database2Values::CreateFromJsArray(const JsArray &sql_arguments,	75 bool Database2Values::CreateFromJsArray(const JsArray *sql_arguments,

70 Database2Values **instance) {	76 Database2Values **instance) {

71 scoped_ptr<Database2Values> result;	77 scoped_ptr<Database2Values> result;

72 result.reset(new Database2Values());	78 result.reset(new Database2Values());

73	79

74 // since the arguments are optional, their token may be NULL	80 // since the arguments are optional, they could be passed as NULL

75 if (sql_arguments.token() == NULL) {	81 if (sql_arguments == NULL) {
Aaron 2008/05/11 18:11:21 It's not a good idea to compare token() to NULL. I It's not a good idea to compare token() to NULL. I don't think there's any guarantee that the js engine represents null js values using NULL. We have a standard way to test for optional arguments in the Gears APIs, using GetArguments(). I would recommend using that, and then passing a pointer to JsArray instead of a reference. If the user did not supply arguments, pass a NULL pointer. Then you can compare that pointer to NULL. Dimitri 2008/05/13 22:52:03 On 2008/05/11 18:11:21, Aaron wrote: > We have a s On 2008/05/11 18:11:21, Aaron wrote: > We have a standard way to test for optional arguments in the Gears APIs, using > GetArguments(). I would recommend using that, and then passing a pointer to > JsArray instead of a reference. If the user did not supply arguments, pass a > NULL pointer. Then you can compare that pointer to NULL. Thank you for making me look this up, cleared up for a lot of things me. As a result, I also reworked Database2Statement::Create method and the way statement callbacks are checked for existence.
76 result->arguments_.reset(NULL);	82 result->arguments_.reset(NULL);

77 result->length_ = 0;	83 result->length_ = 0;

78 *instance = result.release();	84 *instance = result.release();

79 return true;	85 return true;

80 }	86 }

81	87

82 int len;	88 int len;

83 if (!sql_arguments.GetLength(&len)) {	89 if (!sql_arguments->GetLength(&len)) {

84 // unable to query JsArray, someting's gone horribly wrong	90 // unable to query JsArray, someting's gone horribly wrong

85 // returning with failure will trigger an internal error	91 // returning with failure will trigger an internal error
Aaron 2008/05/11 18:11:21 Silent failures look weird to me. Maybe assert(fal Silent failures look weird to me. Maybe assert(false) here. Dimitri 2008/05/13 22:52:03 On 2008/05/11 18:11:21, Aaron wrote: > Silent fail On 2008/05/11 18:11:21, Aaron wrote: > Silent failures look weird to me. Maybe assert(false) here. Done.
	92 assert(false);

86 return false;	93 return false;

87 }	94 }

88	95

89 result->length_ = len;	96 result->length_ = len;

90	97

91 result->arguments_.reset(new JsParamToSend[len]);	98 result->arguments_.reset(new JsParamToSend[len]);

92 for(int i = 0; i < len; i++) {	99 for(int i = 0; i < len; i++) {

93 if (!SetJsParamToSend(sql_arguments, i, result->arguments_.get())) {	100 if (!SetJsParamToSend(sql_arguments, i, result->arguments_.get())) {

94 // one invalid argument make the whole statement bogus	101 // one invalid argument make the whole statement bogus

95 // no need to process any more parameters	102 // no need to process any more parameters

96 // set length to only include last processed parameter	103 // set length to only include last processed parameter

97 result->length_ = i;	104 result->length_ = i;

98 return false;	105 return false;

99 }	106 }

100 }	107 }

101	108

102 *instance = result.release();	109 *instance = result.release();

103 return true;	110 return true;

104 }	111 }

105	112

106 // static	113 // static

107 bool Database2Values::SetJsParamToSend(JsArray js_array,	114 bool Database2Values::SetJsParamToSend(const JsArray *js_array,

108 int index,	115 int index,

109 JsParamToSend *arguments) {	116 JsParamToSend *arguments) {

110 assert(index >= 0 && arguments);	117 assert(index >= 0 && arguments);

111 JsParamToSend *param = arguments + index;	118 JsParamToSend *param = &arguments[index];
Aaron 2008/05/11 18:11:21 Does arguments[index] work? I think it's easier to Does arguments[index] work? I think it's easier to understand. Dimitri 2008/05/13 22:52:03 On 2008/05/11 18:11:21, Aaron wrote: > Does argume On 2008/05/11 18:11:21, Aaron wrote: > Does arguments[index] work? I think it's easier to understand. Easified.
112 param->type = js_array.GetElementType(index);	119 param->type = js_array->GetElementType(index);

113 switch(param->type) {	120 switch(param->type) {

114 case JSPARAM_INT: {	121 case JSPARAM_INT: {

115 scoped_ptr<int> value;	122 scoped_ptr<int> value;

116 value.reset(new int);	123 value.reset(new int);
Aaron 2008/05/11 18:11:21 The heap allocated integers are unfortuante :-/. I The heap allocated integers are unfortuante :-/. I guess this is why variants in all the scripting languages are implemented as unions. I think that long term we want to implement our own Variant, implemented as a union of bool, int, int64, string, JsObject, JsArray, vector<Variant>, map<string, Variant>. Then we can replace JsParamToSend with this class and refactor the MarshaledJsToken code to use it. Then this would all come for free. But I thought about it, and imho, moving forward with Database2 is more important than gettng sidetracked on the variant thing, so this is fine for now. Maybe just add a TODO in the definition of this class. Dimitri 2008/05/13 22:52:03 On 2008/05/11 18:11:21, Aaron wrote: > The heap al On 2008/05/11 18:11:21, Aaron wrote: > The heap allocated integers are unfortuante :-/. I guess this is why variants in > all the scripting languages are implemented as unions. Yes, I agree. > I think that long term we want to implement our own Variant, implemented as a > union of bool, int, int64, string, JsObject, JsArray, vector<variant>, > map<string, variant="">. Then we can replace JsParamToSend with this class and > refactor the MarshaledJsToken code to use it. Then this would all come for free. Yipee! > But I thought about it, and imho, moving forward with Database2 is more > important than gettng sidetracked on the variant thing, so this is fine for now. > Maybe just add a TODO in the definition of this class. Done.
117 if (js_array.GetElementAsInt(index, value.get())) {	124 if (js_array->GetElementAsInt(index, value.get())) {

118 param->value_ptr = value.release();	125 param->value_ptr = value.release();

119 return true;	126 return true;

120 }	127 }

121 return false;	128 return false;

122 }	129 }

123 case JSPARAM_DOUBLE: {	130 case JSPARAM_DOUBLE: {

124 scoped_ptr<double> value;	131 scoped_ptr<double> value;

125 value.reset(new double);	132 value.reset(new double);

126 if (js_array.GetElementAsDouble(index, value.get())) {	133 if (js_array->GetElementAsDouble(index, value.get())) {

127 param->value_ptr = value.release();	134 param->value_ptr = value.release();

128 return true;	135 return true;

129 }	136 }

130 return false;	137 return false;

131 }	138 }

132 case JSPARAM_STRING16: {	139 case JSPARAM_STRING16: {

133 scoped_ptr<std::string16> value;	140 scoped_ptr<std::string16> value;

134 value.reset(new std::string16());	141 value.reset(new std::string16());

135 if (js_array.GetElementAsString(index, value.get())) {	142 if (js_array->GetElementAsString(index, value.get())) {

136 param->value_ptr = value.release();	143 param->value_ptr = value.release();

137 return true;	144 return true;

138 }	145 }

139 return false;	146 return false;

140 }	147 }

141 case JSPARAM_NULL: {	148 case JSPARAM_NULL: {

142 param->value_ptr = NULL;	149 param->value_ptr = NULL;

143 return true;	150 return true;

144 }	151 }

145 }	152 }

146 // all other types are considered invalid	153 // all other types are considered invalid

147 return false;	154 return false;

148 }	155 }

149	156

150 JsParamType Database2Values::GetType(int index) const {	157 JsParamType Database2Values::GetType(int index) const {

151 assert(index >= 0 && index < length_);	158 assert(index >= 0 && index < length_);

152 return arguments_[index].type;	159 return arguments_[index].type;

153 }	160 }

154	161

155 int Database2Values::GetAsInt(int index) const {	162 int Database2Values::GetAsInt(int index) const {

156 assert(index >= 0 && index < length_);	163 assert(index >= 0 && index < length_);

157 JsParamToSend param = arguments_[index];	164 JsParamToSend param = arguments_[index];

158 assert(param.type == JSPARAM_INT);	165 assert(param.type == JSPARAM_INT);

159 return static_cast<int>(const_cast<void*>(param.value_ptr));	166 return static_cast<int>(const_cast<void*>(param.value_ptr));

160 }	167 }

161	168

162 double Database2Values::GetAsDouble(int index) const {	169 double Database2Values::GetAsDouble(int index) const {

163 assert(index >= 0 && index < length_);	170 assert(index >= 0 && index < length_);

164 JsParamToSend param = arguments_[index];	171 JsParamToSend param = arguments_[index];

165 assert(param.type == JSPARAM_DOUBLE);	172 assert(param.type == JSPARAM_DOUBLE);

166 return static_cast<int>(const_cast<void*>(param.value_ptr));	173 return static_cast<int>(const_cast<void*>(param.value_ptr));

167 }	174 }

168	175

169 std::string16 &Database2Values::GetAsString(int index) const {	176 std::string16 &Database2Values::GetAsString(int index) const {

170 assert(index >= 0 && index < length_);	177 assert(index >= 0 && index < length_);

171 JsParamToSend param = arguments_[index];	178 JsParamToSend param = arguments_[index];

172 assert(param.type == JSPARAM_STRING16);	179 assert(param.type == JSPARAM_STRING16);

173 return static_cast<std::string16>(const_cast<void*>(param.value_ptr));	180 return static_cast<std::string16>(const_cast<void*>(param.value_ptr));

174 }	181 }

175	182

176 Database2Values::~Database2Values() {	183 Database2Values::~Database2Values() {

177 // dispose of the data, pointed to the value_ptrs	184 // dispose of the data, pointed to the value_ptrs

178 for(int i = 0; i < length_; i++) {	185 for(int i = 0; i < length_; i++) {

179 JsParamToSend param = arguments_[i];	186 JsParamToSend param = arguments_[i];

180 if (param.value_ptr) delete param.value_ptr;	187 if (param.value_ptr) delete param.value_ptr;

181 }	188 }

182 }	189 }

LEFT	RIGHT