fix: handle query with a string containing a literal question mark

third_party/datastax/proxy/proxy.go

@@ -793,7 +793,7 @@ func (c *client) handleServerPreparedQuery(raw *frame.RawFrame, msg *message.Pre
 // function to handle and delete query of prepared type
 func (c *client) prepareDeleteType(raw *frame.RawFrame, msg *message.Prepare, id [16]byte) ([]*message.ColumnMetadata, []*message.ColumnMetadata, error) {
 	var returnColumns, variableColumns, columnsWithInOp []string
-	deleteQueryMetadata, err := c.proxy.translator.ToSpannerDelete(c.keyspace, msg.Query)
+	deleteQueryMetadata, err := c.proxy.translator.ToSpannerDelete(c.keyspace, msg.Query, false)
 	if err != nil {
 		c.proxy.logger.Error(translatorErrorMessage, zap.String(Query, msg.Query), zap.Error(err))
 		c.sender.Send(raw.Header, &message.Invalid{ErrorMessage: err.Error()})
@@ -879,7 +879,7 @@ func (c *client) prepareInsertType(raw *frame.RawFrame, msg *message.Prepare, id
 // function to handle and select query of prepared type
 func (c *client) prepareSelectType(raw *frame.RawFrame, msg *message.Prepare, id [16]byte) ([]*message.ColumnMetadata, []*message.ColumnMetadata, error) {
 	var variableColumns, columnsWithInOp []string
-	queryMetadata, err := c.proxy.translator.ToSpannerSelect(c.keyspace, msg.Query)
+	queryMetadata, err := c.proxy.translator.ToSpannerSelect(c.keyspace, msg.Query, false)
 	if err != nil {
 		c.proxy.logger.Error(translatorErrorMessage, zap.String(Query, msg.Query), zap.Error(err))
 		c.sender.Send(raw.Header, &message.Invalid{ErrorMessage: err.Error()})
@@ -932,7 +932,7 @@ func (c *client) prepareSelectType(raw *frame.RawFrame, msg *message.Prepare, id
 // function to handle update query of prepared type
 func (c *client) prepareUpdateType(raw *frame.RawFrame, msg *message.Prepare, id [16]byte) ([]*message.ColumnMetadata, []*message.ColumnMetadata, error) {
 	var returnColumns, variableColumns, columnsWithInOp []string
-	updateQueryMetadata, err := c.proxy.translator.ToSpannerUpdate(c.keyspace, msg.Query)
+	updateQueryMetadata, err := c.proxy.translator.ToSpannerUpdate(c.keyspace, msg.Query, false)
 	if err != nil {
 		c.proxy.logger.Error(translatorErrorMessage, zap.String(Query, msg.Query), zap.Error(err))
 		c.sender.Send(raw.Header, &message.Invalid{ErrorMessage: err.Error()})
@@ -1514,10 +1514,10 @@ func (c *client) handleQuery(raw *frame.RawFrame, msg *partialQuery) {
 		}
 	} else {
 		var result *message.RowsResult
-
+		var isSimpleQuery = true
 		switch queryType {
 		case selectType:
-			queryMetadata, err := c.proxy.translator.ToSpannerSelect(c.keyspace, msg.query)
+			queryMetadata, err := c.proxy.translator.ToSpannerSelect(c.keyspace, msg.query, isSimpleQuery)
 			if err != nil {
 				c.proxy.logger.Error(translatorErrorMessage, zap.String(Query, msg.query), zap.Error(err))
 				c.sender.Send(raw.Header, &message.Invalid{ErrorMessage: err.Error()})
@@ -1594,7 +1594,7 @@ func (c *client) handleQuery(raw *frame.RawFrame, msg *partialQuery) {
 
 			c.sender.Send(raw.Header, result)
 		case deleteType:
-			queryMetadata, err := c.proxy.translator.ToSpannerDelete(c.keyspace, msg.query)
+			queryMetadata, err := c.proxy.translator.ToSpannerDelete(c.keyspace, msg.query, isSimpleQuery)
 			if err != nil {
 				c.proxy.logger.Error(translatorErrorMessage, zap.String(Query, msg.query), zap.Error(err))
 				c.sender.Send(raw.Header, &message.Invalid{ErrorMessage: err.Error()})
@@ -1633,7 +1633,7 @@ func (c *client) handleQuery(raw *frame.RawFrame, msg *partialQuery) {
 			result.Metadata.ColumnCount = int32(len(VariableMetadata))
 			c.sender.Send(raw.Header, result)
 		case updateType:
-			queryMetadata, err := c.proxy.translator.ToSpannerUpdate(c.keyspace, msg.query)
+			queryMetadata, err := c.proxy.translator.ToSpannerUpdate(c.keyspace, msg.query, isSimpleQuery)
 			if err != nil {
 				c.proxy.logger.Error(translatorErrorMessage, zap.String(Query, msg.query), zap.Error(err))
 				c.sender.Send(raw.Header, &message.Invalid{ErrorMessage: err.Error()})

translator/translator_delete.go

@@ -45,7 +45,7 @@ func createSpannerDeleteQuery(table string, clauses []Clause) string {
 //   - query: CQL Delete query
 //
 // Returns: DeleteQueryMap struct and error if any
-func (t *Translator) ToSpannerDelete(keyspace string, queryStr string) (*DeleteQueryMap, error) {
+func (t *Translator) ToSpannerDelete(keyspace string, queryStr string, isSimpleQuery bool) (*DeleteQueryMap, error) {
 	lowerQuery := strings.ToLower(queryStr)
 	query := renameLiterals(queryStr)
 	p, err := NewCqlParser(query, t.Debug)
@@ -95,7 +95,7 @@ func (t *Translator) ToSpannerDelete(keyspace string, queryStr string) (*DeleteQ
 	var clauseResponse ClauseResponse
 
 	if hasWhere(lowerQuery) {
-		resp, err := parseWhereByClause(deleteObj.WhereSpec(), tableSpec.TableName, t.TableConfig)
+		resp, err := parseWhereByClause(deleteObj.WhereSpec(), tableSpec.TableName, t.TableConfig, isSimpleQuery)
 		if err != nil {
 			return nil, err
 		}

translator/translator_delete_test.go

@@ -354,7 +354,7 @@ func TestTranslator_ToSpannerDelete(t *testing.T) {
 				Logger:      tt.fields.Logger,
 				TableConfig: tableConfig,
 			}
-			got, err := tr.ToSpannerDelete(tt.args.keyspace, tt.args.query)
+			got, err := tr.ToSpannerDelete(tt.args.keyspace, tt.args.query, false)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Translator.ToSpannerDelete() error = %v, wantErr %v", err, tt.wantErr)
 				return

translator/translator_select.go

@@ -375,7 +375,7 @@ func getSpannerSelectQuery(t *Translator, data *SelectQueryMap) (string, error)
 //   - originalQuery: CQL Select statement
 //
 // Returns: SelectQueryMap struct and error if any
-func (t *Translator) ToSpannerSelect(keyspace string, originalQuery string) (*SelectQueryMap, error) {
+func (t *Translator) ToSpannerSelect(keyspace string, originalQuery string, isSimpleQuery bool) (*SelectQueryMap, error) {
 	lowerQuery := strings.ToLower(originalQuery)
 	//Create copy of cassandra query where literals are substituted with a suffix
 	query := renameLiterals(originalQuery)
@@ -413,7 +413,7 @@ func (t *Translator) ToSpannerSelect(keyspace string, originalQuery string) (*Se
 	var clauseResponse ClauseResponse
 
 	if hasWhere(lowerQuery) {
-		resp, err := parseWhereByClause(selectObj.WhereSpec(), tableSpec.TableName, t.TableConfig)
+		resp, err := parseWhereByClause(selectObj.WhereSpec(), tableSpec.TableName, t.TableConfig, isSimpleQuery)
 		if err != nil {
 			return nil, err
 		}

translator/translator_select_test.go

@@ -539,7 +539,7 @@ func TestTranslator_ToSpannerSelect(t *testing.T) {
 				TableConfig:     tableConfig,
 				UseRowTimestamp: false,
 			}
-			got, err := tr.ToSpannerSelect(tt.args.keyspace, tt.args.query)
+			got, err := tr.ToSpannerSelect(tt.args.keyspace, tt.args.query, false)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Translator.ToSpannerSelect() error = %v, wantErr %v", err, tt.wantErr)
 				return

translator/translator_update.go

@@ -158,7 +158,7 @@ func createSpannerSelectQueryForMapUpdate(table string, columns string, clauses
 //   - query: CQL Update query
 //
 // Returns: UpdateQueryMap struct and error if any
-func (t *Translator) ToSpannerUpdate(keyspace string, queryStr string) (*UpdateQueryMap, error) {
+func (t *Translator) ToSpannerUpdate(keyspace string, queryStr string, isSimpleQuery bool) (*UpdateQueryMap, error) {
 	lowerQuery := strings.ToLower(queryStr)
 	query := renameLiterals(queryStr)
 	p, err := NewCqlParser(query, t.Debug)
@@ -352,7 +352,7 @@ func (t *Translator) ToSpannerUpdate(keyspace string, queryStr string) (*UpdateQ
 	var clauseResponse ClauseResponse
 
 	if hasWhere(lowerQuery) {
-		resp, err := parseWhereByClause(updateObj.WhereSpec(), tableName, t.TableConfig)
+		resp, err := parseWhereByClause(updateObj.WhereSpec(), tableName, t.TableConfig, isSimpleQuery)
 		if err != nil {
 			return nil, err
 		}

translator/translator_update_test.go

@@ -250,7 +250,7 @@ func TestTranslator_ToSpannerUpdate(t *testing.T) {
 				UseRowTimestamp: true,
 				UseRowTTL:       true,
 			}
-			got, err := tr.ToSpannerUpdate(tt.args.keyspace, tt.args.query)
+			got, err := tr.ToSpannerUpdate(tt.args.keyspace, tt.args.query, false)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Translator.ToSpannerUpdate() error = %v, wantErr %v", err, tt.wantErr)
 				return
@@ -326,7 +326,7 @@ func TestTranslator_ToSpannerUpdateWhenUsingTSTTLIsDisabled(t *testing.T) {
 				UseRowTimestamp: false,
 				UseRowTTL:       false,
 			}
-			got, err := tr.ToSpannerUpdate(tt.args.keyspace, tt.args.query)
+			got, err := tr.ToSpannerUpdate(tt.args.keyspace, tt.args.query, false)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("Translator.ToSpannerUpdate() error = %v, wantErr %v", err, tt.wantErr)
 				return

translator/utils.go

@@ -415,9 +415,10 @@ func NewCqlParser(cqlQuery string, isDebug bool) (*cql.CqlParser, error) {
 //   - input: The Where Spec context from the antlr Parser.
 //   - tableName - Table Name
 //   - tableConfig - JSON Config which maintains column and its datatypes info.
+//   - isSimpleQuery - Whether or not this where clause is part of query statement.
 //
 // Returns: ClauseResponse and an error if any.
-func parseWhereByClause(input cql.IWhereSpecContext, tableName string, tableConfig *tableConfig.TableConfig) (*ClauseResponse, error) {
+func parseWhereByClause(input cql.IWhereSpecContext, tableName string, tableConfig *tableConfig.TableConfig, isSimpleQuery bool) (*ClauseResponse, error) {
 	if input == nil {
 		return nil, errors.New("no input parameters found for clauses")
 	}
@@ -487,16 +488,18 @@ func parseWhereByClause(input cql.IWhereSpecContext, tableName string, tableConf
 				if value == "" {
 					return nil, errors.New("could not parse value from query for one of the clauses")
 				}
-				value = strings.ReplaceAll(value, "'", "")
 
-				if value != questionMark {
-
-					val, err := formatValues(value, columnType.SpannerType, columnType.CQLType)
-					if err != nil {
-						return nil, err
+				if isSimpleQuery && value == "'?'" {
+					params[placeholder] = questionMark
+				} else {
+					value = strings.ReplaceAll(value, "'", "")
+					if value != questionMark {
+						val, err := formatValues(value, columnType.SpannerType, columnType.CQLType)
+						if err != nil {
+							return nil, err
+						}
+						params[placeholder] = val
 					}
-
-					params[placeholder] = val
 				}
 			} else {
 				lower := strings.ToLower(val.GetText())

translator/utils_test.go

@@ -880,6 +880,7 @@ func TestParseWhereByClause(t *testing.T) {
 		input          string
 		tableName      string
 		tableConfig    tableConfig.TableConfig
+		isQuery        bool
 		keyspace       string
 		expectedResult *ClauseResponse
 		expectedErr    error
@@ -905,6 +906,46 @@ func TestParseWhereByClause(t *testing.T) {
 			},
 			expectedErr: nil,
 		},
+		{
+			name:      "Valid input with question mark in quotes",
+			input:     "WHERE column1 = '?'",
+			tableName: "test_table",
+			keyspace:  "key_space",
+			expectedResult: &ClauseResponse{
+				Clauses: []Clause{
+					{
+						Column:       "column1",
+						Operator:     "=",
+						Value:        "@value1",
+						IsPrimaryKey: true,
+					},
+				},
+				Params: map[string]interface{}{
+					"value1": "?",
+				},
+				ParamKeys: []string{"value1"},
+			},
+			expectedErr: nil,
+		},
+		{
+			name:      "Valid input with question mark",
+			input:     "WHERE column1 = ?",
+			tableName: "test_table",
+			keyspace:  "key_space",
+			expectedResult: &ClauseResponse{
+				Clauses: []Clause{
+					{
+						Column:       "column1",
+						Operator:     "=",
+						Value:        "@value1",
+						IsPrimaryKey: true,
+					},
+				},
+				Params:    map[string]interface{}{},
+				ParamKeys: []string{"value1"},
+			},
+			expectedErr: nil,
+		},
 		{
 			name:      "Valid input with multiple clauses",
 			input:     "WHERE column1 = 'test' AND column2 < '0x0000000000000003'",
@@ -1012,7 +1053,7 @@ func TestParseWhereByClause(t *testing.T) {
 				input = p.WhereSpec()
 
 			}
-			result, err := parseWhereByClause(input, test.tableName, tableConfig)
+			result, err := parseWhereByClause(input, test.tableName, tableConfig, true)
 
 			// Validate error
 			if (err == nil && test.expectedErr != nil) || (err != nil && test.expectedErr == nil) || (err != nil && test.expectedErr != nil && err.Error() != test.expectedErr.Error()) {