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: ready for another look. Created 3 months, 3 weeks ago

Right Patch Set: Created 4 months 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 JsArray *sql_arguments,	47 const 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(new Database2Statement());	51 scoped_ptr<Database2Statement> statement;

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

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

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

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

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

62	56

63 Database2Values *arguments;	57 Database2Values *arguments;

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

65 return false;	59 return false;

66 }	60 }

67	61

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

69	63

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

71 return true;	65 return true;

72 }	66 }

73	67

74 // static	68 // static

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

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

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

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

79	73

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

81 if (sql_arguments == NULL) {	75 if (sql_arguments.token() == 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.
82 result->arguments_.reset(NULL);	76 result->arguments_.reset(NULL);

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

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

85 return true;	79 return true;

86 }	80 }

87	81

88 int len;	82 int len;

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

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

91 // returning with failure will trigger an internal error	85 // 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);

93 return false;	86 return false;

94 }	87 }

95	88

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

97	90

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

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

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

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

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

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

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

105 return false;	98 return false;

106 }	99 }

107 }	100 }

108	101

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

110 return true;	103 return true;

111 }	104 }

112	105

113 // static	106 // static

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

115 int index,	108 int index,

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

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

118 JsParamToSend *param = &arguments[index];	111 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.
119 param->type = js_array->GetElementType(index);	112 param->type = js_array.GetElementType(index);

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

121 case JSPARAM_INT: {	114 case JSPARAM_INT: {

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

123 value.reset(new int);	116 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.
124 if (js_array->GetElementAsInt(index, value.get())) {	117 if (js_array.GetElementAsInt(index, value.get())) {

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

126 return true;	119 return true;

127 }	120 }

128 return false;	121 return false;

129 }	122 }

130 case JSPARAM_DOUBLE: {	123 case JSPARAM_DOUBLE: {

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

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

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

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

135 return true;	128 return true;

136 }	129 }

137 return false;	130 return false;

138 }	131 }

139 case JSPARAM_STRING16: {	132 case JSPARAM_STRING16: {

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

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

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

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

144 return true;	137 return true;

145 }	138 }

146 return false;	139 return false;

147 }	140 }

148 case JSPARAM_NULL: {	141 case JSPARAM_NULL: {

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

150 return true;	143 return true;

151 }	144 }

152 }	145 }

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

154 return false;	147 return false;

155 }	148 }

156	149

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

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

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

160 }	153 }

161	154

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

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

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

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

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

167 }	160 }

168	161

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

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

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

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

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

174 }	167 }

175	168

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

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

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

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

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

181 }	174 }

182	175

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

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

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

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

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

188 }	181 }

189 }	182 }

LEFT	RIGHT