func()

in cassandra-bigtable-migration-tools/cassandra-bigtable-proxy/translator/translator_update.go [375:461]
77 lines of code
10 McCabe index (conditional complexity)

func (t *Translator) BuildUpdatePrepareQuery(columnsResponse []Column, values []*primitive.Value, st *UpdateQueryMapping, protocolV primitive.ProtocolVersion) (*UpdateQueryMapping, error) {
	var newColumns []Column
	var newValues []interface{}
	var primaryKeys []string = st.PrimaryKeys
	var err error
	var unencrypted map[string]interface{}
	var delColumnFamily []string
	var delColumns []Column                            // Added missing declaration
	var prepareOutput *ProcessPrepareCollectionsOutput // Declare prepareOutput

	if len(primaryKeys) == 0 {
		primaryKeys, err = getPrimaryKeys(t.SchemaMappingConfig, st.Table, st.Keyspace)
		if err != nil {
			fmt.Println("Not able to fetch primary keys:", err)
			return nil, err
		}
	}
	timestampInfo, values, err := ProcessTimestampByUpdate(st, values)

	if err != nil {
		return nil, err
	}

	prepareInput := ProcessPrepareCollectionsInput{
		ColumnsResponse: columnsResponse,
		Values:          values,
		TableName:       st.Table,
		ProtocolV:       protocolV,
		PrimaryKeys:     primaryKeys,
		Translator:      t,
		KeySpace:        st.Keyspace,
		ComplexMeta:     st.ComplexOperation,
	}

	prepareOutput, err = processCollectionColumnsForPrepareQueries(prepareInput)
	if err != nil {
		return nil, err
	}
	newColumns = prepareOutput.NewColumns
	newValues = prepareOutput.NewValues
	unencrypted = prepareOutput.Unencrypted
	indexEnd := prepareOutput.IndexEnd
	delColumnFamily = prepareOutput.DelColumnFamily
	delColumns = prepareOutput.DelColumns

	for i, clause := range st.Clauses {
		var column Column
		if columns, exists := t.SchemaMappingConfig.TablesMetaData[st.Keyspace][st.Table][clause.Column]; exists {
			column = Column{Name: columns.ColumnName}
		}

		if slices.Contains(primaryKeys, column.Name) {

			val, _ := utilities.DecodeBytesToCassandraColumnType(values[i+indexEnd+1].Contents, st.VariableMetadata[i+indexEnd+1].Type, protocolV)
			unencrypted[column.Name] = val
		}
	}

	pmks, err := t.SchemaMappingConfig.GetPkByTableNameWithFilter(st.Table, st.Keyspace, primaryKeys)
	if err != nil {
		return nil, err
	}
	rowKeyBytes, err := createOrderedCodeKey(pmks, unencrypted, t.EncodeIntValuesWithBigEndian)
	if err != nil {
		return nil, err
	}
	rowKey := string(rowKeyBytes)

	UpdateQueryData := &UpdateQueryMapping{
		Query:                 st.Query,
		QueryType:             st.QueryType,
		Keyspace:              st.Keyspace,
		Columns:               newColumns,
		Values:                newValues,
		PrimaryKeys:           primaryKeys,
		RowKey:                rowKey,
		Table:                 st.Table,
		DeleteColumnFamilies:  delColumnFamily,
		DeleteColumQualifires: delColumns,
		Clauses:               st.Clauses,
		TimestampInfo:         timestampInfo,
		IfExists:              st.IfExists,
		ComplexOperation:      st.ComplexOperation,
	}

	return UpdateQueryData, nil
}